Manuel de Programmation des
Robots de Combats


Introduction au combat Robotisé:

Pour commencer :

Utilisez les Robots de Combat dans l'arène Officielle

Entrez votre Robot de Combat

Observation d'un match

Contrôlez les Caméras

Les Caméras Robot #1 & Robot #2

Les caméras suiveuses Robot #1 & Robot #2

Les caméras de l' Arène

Caméra libre

Zoom

Vues secondaires

"Connaître le Score"

Programmez votre robot (par l'exemple)

Commentaires Utilisateurs

Initialisez votre robot

Fonction IA du Robot

Annexe A: Commandes et Variables IA

Commandes

Variables de Contrôle du Robot

Variables Environment

Annexe B: Chassis des Robots

Annexe C: Système d'armement

Annexe D: Physique des Robots

Bienvenue à la grande famille galactique des propriétaires de robot de combat de Ctec. Nous espérons que votre robot de combat de Ctec vous apportera beaucoup d'heures saines et amusante de combat de robot . Les robots de Ctec sont conçus pour être faciles d'emploi tout en maintenant la fiabilité, la "survivabilité" et le potentiel de dommages que vous attendez d'un robot de combat.

Pour avoir une grande satisfaction avec ce robot, nous vous encourageons à vous familiariser avec la description des équipements, les instructions d'utilisation et le guide de programmation dans ce manuel. Nous vous invitons également à observer tous les protocoles de sûreté tout en programmant, exécutant, ou récupérant votre robot de combat. VEUILLEZ NE PAS ACTIONNER UN ROBOT DE COMBAT EN ETANT SOUS L'INFLUENCE DE L'ALCOOL, D'UN MÉDICAMENT OU DE TOUT AUTRE ALTERATION DE VOS CAPACITES PHYSIQUES ET/OU INTELLECTUELLES

N'actionnez pas votre robot de combat sur d'autres mondes avant d'étudier les règlements applicables au robot et aux armes de ce monde. Dans certains cas il peut être impossible ou difficile de se conformer à ces règlements. Les GT&W interdisent strictement d'apporter un robot de combat à n'importe quelle classe du monde 1, 2 ou 3!

Introduction au Combat Robotisé:

Dans le passé (à l'époque des barbares) c'était commun que des désaccords entre des individus, des nations et des mondes soient résolus en tuant les formes de vie des deux côtés. Ces conflits brutaux ont abouti à ce que des vies innombrables soient perdues et que des ressources valant des milliards de crédits soient gaspillées. Un nombre indicible d'espèce a été enlevé de la galaxie en raison de ce type de comportement.

Si l'une de ces espèces hostiles avait une assez haute technologie, elle créait parfois les robots qui pouvaient être employés pour combattre à leur place. Cela sauvait des vies pour ceux qui possédaient les robots, mais ont augmenté la perte de vie pour ceux qui n'en avaient pas. Si les deux planètes étaient assez avancées elles emploieraient toutes les deux des robots pour combattre l'une avec l'autre. Cela a énormément réduit la perte de vie des deux côtés, mais les dégâts à l'environnement environnant et à l'économie étaient tout de même très importants.

Cela a continué longtemps jusqu'à ce que finalement, le Commerce Galactique et l'Organisation de Guerre, appelé en ces temps-là seulement l'Organisation Commerciale Galactique, aient décidé que la perte de ressources dans ces conflits desservait défavorablement l'économie galactique. Ils ont imposé des règles strictes et des directives pour dire comment les conflits pourraient être traités. Sous les nouvelles règles les deux côtés concluraient un accord dans lequel chaque côté créerait un robot qui rivaliserait contre un robot simple créé par l'autre côté. Le combat aurait lieu dans une arène particulièrement sanctionnée sur un monde neutre. Le gagnant du combat gagnerait ce qui a été convenu et le perdant se verrait alloué une immunité provisoire à n'importe quel conflit.

Cette solution est devenue extrêmement populaire parmi les planètes 'civilisées' (les planètes refusant de résoudre leurs conflits sont de cette manière considérées ' dangereuse' et sont mises en quarantaine du reste de la galaxie). Une fois que le réseau Galactique (GNet) a été institué, la nourriture vivante de parties de robot y est rapidement devenue la deuxième chose la plus vue (directement après "des rituels d'accouplement"). Avec les paris sur place, le tourisme et les ventes de billet, accueillir un match sur votre planète était une grande source de revenu. Les parties sont devenues si populaires que beaucoup de planètes ' composeraient ' des désaccords avec une autre juste pour créer un match pour retransmettre. Pour réduire le nombre de ces conflits composés, le Commerce Galactique et l'Organisation de Guerre ont démarré une 'branche spéciale formation ' de conflit de robot, ainsi la Ligue Robotisée de Combat a été créée et le Combat de Robot est devenu un événement sportif officiel.

Pour Commencer:

Votre Robot de combat Ctec est livré complet avec toutes ses armes, senseurs et sources électriques nécessaires pour participer aux compétitions. Les seules choses manquantes sont l'ensemble des instructions (appelées script) employées pour piloter le robot dans le combat. Lorsque vous concourez dans une compétition de type "chassis fixe" chaque robot doit se conformer à un cahier des charges précis. Ce qui signifie que c'est le script pour chaque robot, et non pas le matériel, qui différenciera les gagnants des perdants.

Pour vous aider à commencer nous avons inclus un couple de scripts préécrits de base pour que votre robot puisse fonctionner. Vous pouvez expérimeneter le combat de robot immédiatement en chargeant un de ces 2 scripts dans votre robot et en démarrant le match. (Voir "Entrez votre Robot de Combat" un peu plus loin). Vous pouvez également utilsez ces scripts comme point de départ pour vos propres robots de combat (voir "programmez votre Robot" un peu plus loin).

Utilisez des Robots de Combat dans une Arène Officielle

Afin d'empêcher tout conflit physique dans la majeure partie de la galaxie civilisée, la plupart des robots sont employés uniquement dans des combats sportifs en arènes. Les arènes de Combat de Robots (Robot Combat Arenas ou RCA) permettent un maximum de plaisir avec les Robots de combats tout en minimisant les effets nuisibles sur l'environnement du monde.

Entrez votre Robot de Combat

Pour entrer votre robot dans un match en arène, démarrez simplement le lanceur GArena ("GArena Launcher" ouGAL) et sélectionnez les 2 IA de robot à partir du répertoire IA préconstruit (ou du répertoire de votre choix). Une fois les IA sélectionnés, pressez "Launch Game" et le programme s'occupera du reste.

 

Observation d'un match

En raison de la popularité du combat de robot d'arène, de la distance de l'arène à votre maison, et des incompatibilités possibles d'atmosphère, la meilleure manière d'observer votre combat de robot est de le regarder le match en direct grâce aux réseaux de caméras GNet dans le confort de votre propre habitat. Le lanceur de GArena vous commutera automatiquement au réseau des caméras de GNet quand vous envoyez vos robots au RCA.

Lorsqu'un match commence, il vous sera proposé la vue par défaut de l'arène (normalement une vue de l'arène) et peut-être une ou plusieurs fenêtres secondaires qui pourront afficher d'autres vues.


1) Vue principale: c'est la fenêtre qui est sous votre contrôle (voir contrôler les caméras un peu plus loin).
2) Nom de la vue courante: c'est le nom de la vue courante de la caméra principale.
3) vues secondaires: vous pouvez avoir de 0 à 4 vues secondaires (voir "vues secondaires" un peu plus loin).
4) Chronomètre: décompte le temps (en secondes) restant dans ce match
5) Etat du Robot: affiche l'état courant du robot (voir "connaître le score" un peu plus loin).
6) Ligne des Messages: affiche le dernier évènement significatif qui est arrivé.

Contrôler les Caméras

Vous pouvez changer la vue principale par l'une de ces 6 vues de caméras.

Caméra Robot #1 & Robot #2

En pressant la touche "1" ou "2" vous recevrez la vue "vue de l'intérieur du robot" pour le robot #1 ou #2. C'est une des vues les plus exitantes dans le jeu (surtout si le robot donne ou reçoit l'estocade finale) mais il est souvent difficile d'avoir une vue d'ensemble du match à partir de cette vue.

Caméra suiveuse Robot #1 & Robot #2

En pressant la touche ‘3’ ou ‘4’ vous recevrez la vue "suivre le robot" pour le robot #1 (3) ou #2 (4). Ces vues vous placent dans une caméra qui est flotte derrière le robot. Elles combinent l'excitation de la vue "à l'intérieur du robot" tout en vous permettant une meilleure visibilté de l'environnement du robot.

Caméras d'Arène

La touche ‘5’ bascule sur l'une des nombreuses caméras fixes positionnées tout autour de l'arène. Ces caméras sont programmées pour suivreles 2 robots en compétiton pendant toute la durée du match. key switches to one of the many Arena Cameras located in fixed positions around the arena. These cameras are programmed to follow both robot competitors during the match. Si les 2 robots ne tiennent pas dans la vue la caméra se concentrera sur le robot le plus proche

La caméra d'arène est unique bien qu'il y ait réellement plus d'ue caméra. Toutes les caméras sont stockées dans une liste, avec lae dernière caméra de la liste pointant sur la première caméra. Si vous utilisez déjà la vue de caméra d'arène, en pressant de nouveau la touche '5' vous commuterez sur la prochaine caméra de la liste. Continuez d'appuyer sur cette touche jusqu'à ce que vous trouviez la vue que vous souhaitez.

Caméra libre

La caméra libre est très différente des autres caméras dans la mesure où c'est vous qui la contrôlez. En pressant la touche ‘TAB’ vous créerez une nouvelle vue de caméra à la place de la caméra courante. Vous pouvez déplacer cette caméra avec la souris. Le bouton gauche déplace la caméra vers l'avant, le bouton droit vers l'arrière et en déplaçant la souris vous contrôlez les angles tilt et pan de la caméra.

Zoom

Vous pouvez zoomer la caméra en pressant la touche ‘Z’ (zoom avant) et ‘X’ (zoom arrière). Chaque pression sur la touche double (ou divise de moitié) le facteur zoom de la caméra.

Vues secondaires

Vous pouvez afficher jusqu'à 4 vues secondaires en bas de la fenêtre de la vue principale. Les vues secondaires vous permettent de surveiller des vues multiples en même temps et de commuter librement ces vues. Notez: vous pouvez seulement changer le type de caméra de la fenêtre de la vue principale. Pour changer une camera de vue secondaire, vous devez la permuter avec la vue principale.

Pour activer une vue secondaire, pressez l'une des touches correspondantes aux vues secondaires. Ces touches sont ‘Q’,’W’,’E’, et ‘R’. Si l'une des vues secondaires est déjà active, le fait de presser la touche correspondante permuttera cette vue avec la vue principale. Par exemple lorsque vous pressez la touche 'Q’ alors que cette vue secondaire est déjà visible, la vue secondaire deviendra vue principale (et la vue principale qui était là deviendra vue secondaire).

Pour déasctiver une vue secondaire, presser et maintenez la touche "Ctrl" enfoncée et pressez la touche correspondant à la vue secondaire à désactiver.

"Connaître le Score"

Durant le match vous pouvez suivre les statistiques vitales de chaque robot en consultant leurs informations "Etat du Robot" sur l'écran de la vue principale. L'affichage sur la partie gauche de l'écran est pour le robot #1; l'affichage sur la partie gauche de l'écran est pour le robot#2. Vous y trouverez les informations suivantes:


1) Portrait du Robot : image de votre robot (avant qu'il ne soit endommagé).
2) Santé actuelle: lorsque la barre est vide, votre robot est détruit.
3) munition1: nombre de cartouches (roquette, balles, obus, etc.) dans l'arme principale.
4) munition2: nombre de cartouches (roquette, balles, obus, etc.) dans l'arme secondairen.

La barre rouge sous les deux compteurs de munitions montre graphiquement combien de temps il faut pour que l'arme soit rechargée (noir > 10 secondes, complètement rouge = rechargée).

Au centre inférieur de l'écran, au-dessus du nom de la caméra de vue courante, vous trouverez la ligne de message. Celle-ci vous indiquera le dernier événement significatif qui s'est produit dans le match. Ne vous inquiétez pas si vous manquez un événement parce que le prochain événement arrivera bien après, une trace de tous les événements est sauvegardée sur votre ordinateur ("gamelog.txt") ainsi vous pouvez les regarder pendant vos loisirs. Le message d'événement inclut un affichage de temps, la seconde où une action s'est produite.

Programmez votre robot (par exemple)

Puisque les robots sont déjà construits, fournis avec leur armement et leur armure, la seule chose qui va différencier un robot d'un autre est sa programmation. Les ganants se distingueront des perdants uniquement par leur compétence à programmer seuls leur robot. Heureusement, nous avons rendu la programmation de votre robot Ctec aussi facile que possible.

Nous allons étudier l'un de ces scripts IA préconstruit exemple.gs. Vous trouverez ce script dans votre répertoire "rscript", ouvrez le avec un éditeur 'plein texte' (i.e. Notepad). Ouvrez ce script maintenant et suivez le cheminent des diiférentes étapes de programmation de votre robot. Si vous trouvez une variable ou une commande et que vous voulez en savoir plus à son sujet, une liste complète peut être trouvée dans l'annexe A: Commandes et variables de l'IA

Commentaires Utilisateurs

La première chose que nous voyons lorsque nous regardons le script du robot est un 'commentaire utilisateur':

// exemple Robot Number 1

Vous pouvez voir des blocs de commentaires tout au long du script. Ils sont utilisés par celui qui écrit le script pour ajouter des commentaires aux lignes de code; elles n'affectent en aucun cas le comportement du robot (elles sont simplement ignorées par le robot pendant l'exécution).

Les commentaires utilisateurs peuvent avoir 2 formes : simple ligne et lignes multiplesLes commentaires simple ligne sont repérés par ‘//’ qui fait que tous les caractères qui suivent sont un commentaire. Par exemple :

do_something(); // je suis un commentaire

Le "do_something();" est lu par le robot mais la partie "je suis un commentaire" est ignoré.

Un commentaire multi lignes commence par ‘/*’ et se termine par ‘*/’. Le robot ignore tout ce qui se trouve entre ces 2 symboles. Par exemple:

/* début des commentaires
   suite des commentaires
   fin des commentaires ici */

Le robot ignoera ces 3 lignes.

 

Initialisez votre robot

Après différentes lignes de commentaires, vous arrivez à vos premières lignes de code:

function LOAD_ROBOT()
{
   robot_type = 1; // utilise robot #1
}

 

C'est la fonction de chargement du robot. Elle est exécutée une fois avant que le match ne soit commencé et ne sert normalement qu'à sélectionner le type de robot à charger (dans notre cas robot #1).

   robot_type = 1; // utilise robot #1

Cette ligne valide le type de robot. La variable robot_type est une variable robot spéciale car elle ne peut être validée que dans la fonction robot_load. Elle indique à l'arène quel type de chassis de robot vous projetez d'utiliser (1,2,3, or 4).

Vous pouvez valider d'autres valeurs initiales ici. Mais chaque validation de valeur dans cette fonction ne sera faite qu'une fois (lorsque le robot sera chargé).

 

La fonction IA du Robot

Une fois que le match est commencé, la fonction d'IA du robot est appelée à chaque tour. C'est ici que vous donnez vos instructions à votre robot, sur ce qu'il doit faire en fonction des données qu'il a recueillies sur ses senseurs et les données qu'il a précédemment stockées dans cette fonction.

function AI_ROBOT()
{
   // se tourner vers la cible
   if(angle_to_target > 5)
   {
      // tourne à gauche
      force_left = -5;
      force_right = 100;
   }
   else
   {
      if(angle_to_target < -5)
      {
         // tourne à droite
         force_left = 100;
         force_right = -5;
      }
      else
      {
         // avance, pleine vitesse
         force_left = 100;
         force_right = 100;

         // contrôle des armes
         // tirer seulement lorsque angle cible est > 5 et< -5
         // et le robot dans la portée de l'arme.
         if(distance_to_target < 2000)
         {
            gun2_fire = 1; // tire avec arme secondaire
         }

         if(distance_to_target > 50)
         {
            gun1_fire = 1; // tire avec arme primaire
         }
      }
   }
}

C'est la deuxième fonction de notre script et comme pour LOAD_ROBOT, elle doit être nommée exactement comme indiqué.

function AI_ROBOT()
{

La première chose que nous rencontrons à l'intérieur du corps de la fonction est une instruction ‘if else’:

   // se tourner vers la cible
   if(angle_to_target > 5)
   {
      // tourne à gauche
      force_left = -5;
      force_right = 100;
   }
   else
   {

L'instruction vérifie une variable environnementale angle_to_target, qui donne l'angle relatif de la cible à la face courante de votre robot. Si cette valeur est supérieure à 5 ("if(angle_to_target > 5)") alors la cible est à plus de 5° sur la gauche de votre robot. Dans ce cas nous voulons le faire tourner dans le sens contraire des aiguilles d'une montre pour faire face à notre cible, nous faisons cela en déplaçant la rouge gauche moins rapidement que la roue droite. (voir annexe D : Physique du robot un peu plus loin si vous ne comprenez pas pourquoi).

Si la cible n'est pas à plus de 5 ° à notre gauche, nous exécutons le code de la partie else de notre instruction:

   if(angle_to_target < -5)
   {
      // tourne à gauche
      force_left = -5;
      force_right = 100;
   }
   else

A l'intérieur de l'instruction else on trouve une autre instruction ‘if else’. Celle-ci est identique à la première excepté que nous regardons si l'angle est inférieur de -5° placé sur la droite du robot. Si cette déclaration est vraie, nous tournons le robot dans le sens des aiguilles d'une montre.

La section de code suivante est à l'intérieur d'une double instruction, aussi elle est exécutée uniquement si les 2 déclarations sont fausses. En clair le code suivant est exécuté seulement si angle_to_target <= 5 ET angle_to_target >= -5. En d'autres termes si angle_to_target est dans l'intervalle –5 à +5.

Le premier bloc de code doit être facile à lire:

      // avance, pleine vitesse
      force_right = 100;
      force_left = 100;


Puisque nous faisons face à la cible nous pouvons aller de l'avant à pleine vitesse.

Le bloc de code suivant manipule les armes à feu. Il utilise 2 déclarations IF:

 

      if(distance_to_target < 2000)
      {
         gun2_fire = 1; // tire avec arme secondaire
      }
      if(distance_to_target > 50)
      {
         gun1_fire = 1; // tire avec arme primaire
      }

 

Puisque ce code se trouve dans un bloc qui n'est exécuté que lorsque le robot fait face à la cible, nous devons vérifier la portée pour savoir quelle arme utiliser. Sachant que le robot type #1 rdispose d'un canon et d'une mitrailleuse comme arme primaire et secondaire, nous demandons au code de choisir l'une ou l'autre en fonction de la distance nous séparant de la cible.

La première instruction if vérifie si nous sommes dans la portée de la mitrailleuse (2000 quants). Si oui nous mettons la variable gun2_fire à 1. Ce qui dit à l'armede tirer une cartouche dés qu'il le pourra. Si l'arme est chargée, elle pourra tirer une cartouche dès la fin du cycle.

La deuxième instruction IF fait exactement le contraire. Puisque le canon a une grande portée il n'est pas nécessaire de vérifier s'il peut atteindre sa cible, mais il est nécessaire de vérifier que la cible est suffisamment loin pour que notre robot ne subisse pas les dégâts dus au soufle de sa propre arme. C'est pourquoi nous vérifions qu'il y ait au moins 50 quants avant de pouvoir tirer

 

Fonctions locales du Robot

Maintenant vous avez un robot entièrement fonctionnel mais ce n'est pas le robot le plus futé de la galaxie. Par la suite vous allez vouloir l'améliorer en ajoutant plus de code. C'est relativement facile à faire, tapez juste plus de lignes dans la fonction '"AI_robot", testez votre robot, ajoutez plus de lignes, et répétez aussi souvent que nécessaire. L'inconvénient de cette méthode et que plus vous ajouterez de lignes de code à votre fonction, plus cela deviendra difficile de le lire et de le mettre au point.

Pour vousaider, découper votre code en sections plus maniables. Nous vous avons fourni huit fonctions 'locales' appelées: FUNC_ONE, FUNC_TWO et ainsi de suite jusqu'à FUNC_EIGHT. Ces fonctions sont employées plus ou moins de la même façon que les fonctions LOAD_ROBOT et Ai_ROBOT excepté le fait que vous pouvez les appeler vous-même. Par exemple, notre IA précédente peut maintenant être écrite comme suit:

function LOAD_ROBOT()
{
   robot_type = 1; // utilise robot #1
}

// Desc: gestion du mouvement
function FUNC_ONE()
{
   // se tourne vers la cible
   if(angle_to_target > 5)
   {
      // tourne à gauche
      force_left = -5;
      force_right = 100;
   }
   else
   {
      if(angle_to_target < -5)
      {
         // tourne à droite
         force_left = 100;
         force_right = -5;
      }
      else
      {
         // avance à pleine vitesse
         force_left = 100;
         force_right = 100;
      }
   }
}

// Desc: contrôle des tirs
function FUNC_TWO()
{
   // contrôle des armes
   // tirer seulement lorsque angle cible est > 5 et< -5
   if((angle_to_target < 5) && (angle_to_target > -5))
   {
      // et le robot dans la portée de l'arme.
      if(distance_to_target < 2000)
      {
         gun2_fire = 1; // armement secondaire
      }

      if(distance_to_target > 50)
      {
         gun1_fire = 1; // armement primaire
      }
   }
}

function AI_ROBOT()
{
   FUNC_ONE(); // gestion du mouvement
   FUNC_TWO(); // contrôle des tirs
}

 

Ce qui fait que la fonction "AI_ROBOT" est beaucoup plus facile à lire. Cette compartimentisation de votre code permet également de remplacer plus facilement une fonction ou de copier cette même fonction vers un autre script de robot.

Les fonctions locales sont un outil très puissant mais vous ne devez pas oublier une chose importante, les boucles sans fin. Cela peut arriver si une de vos fonctions appelle AI_ROBOT() ou si une fonction appelle une autre fonction qui elle même appelle cette fonction.

Par exemple:

function FUNC_ONE()
{
   FUNC_TWO(); // appelle la fonction 2
}

function FUNC_TWO()
{
   FUNC_ONE(); // appelle la fonction 1
}

function AI_ROBOT()
{
   FUNC_ONE(); // appelle la fonction 1
}

Si vous faites un méli-mélo de ce type, votre robot causer une erreur fatale ("fatal engine error") et votre robot sera disqualifié.and your robot will be disqualified.

Félicitations!

Ca y est, vous avez accompli votre premier robot de combat. Cette conception est extrêmement simple mais efficace. C'est une bonne base pour vos futures conceptions de robot.

Pour concevoir un meilleur robot, jetez un coup d'oeil aux autres conceptions dans le répertoire du robot AI et regardez les annexes dans ce manuel pour découvrir ce que votre robot peut faire et comment communiquer avec lui. Avec un peu d'effort et un bon nombre de pratique votre robot de combat de Ctec peut vous donner des années de plaisir.

 

Annexe A: Commandes et variables IA

Commandes du Robot

Les commandes suivantes sont disponibles pour l'utilisation dans votre script robot:

= (l'opérateur d'assignation)
Vous devez utiliser ‘=’ pour assigner une valeur ou un résultat d'une fonction ou d'une expression arithmétique à une variable.
Exemple 1:
value1 = -5; // assigne -5 à value1
Exemple 2: value1 = abs(-5); // assigne le résultat de "abs(-5)" (+5) à value1
Exemple 3:
value1 = 3+2; // assigne le résultat de "3 + 2" à value1

+,-,*,/,(,)
Vous pouvez utiliser ces opérateurs mathématiques pour créer des expressions arithmétiques.
exemple:
value1 = (3+2)*4; // assigne le résultat de "(3 + 2)*4" à value1

+=,-=,*=,/=
"var += expression" est le raccourci pour "var = var + expression".
exemple:
value1 += 5; // value1 = value1 + 5

abs(x)
Retourne la valeur absolue de x.
exemple:
value1 = abs(-55); // value1 = 55;

asin(x), acos(x), atan(x)
sin(x), cos(x), tan(x)
Retourne la valeur trigonométrique où x est l'angle en degrés.
exemple:
value1 = sin(90); // value1 = 1;

ang(x)
Retourne la valeur x ‘décalée’ par un multiple de 360 en une valeur comprise entre –180 et +180.
exemple:
value1 = ang(270); // value1 = -90

fsin(x,f), fcos(x,f), ftan(x,f)
fasin(x,f), facos(x,f), fatan(x,f)
Retourne la valeur des fonctions trigonométriques sans le 'f' (vues au dessus) multipliée par la valeur f.
exemple:
value1 = fsin(90,7); // value1 = 1 * 7 = 7

frc(x)
Retourne la partie fractionaire de x.
exemple:
value1 = frc(543.29); // value1 = 0.29

if( expression ) {instruction block 1 }
if( expression ) { instruction block 1 } else { instruction block 2 }
Le code dans l'instruction block 1 est exécuté si l'expression évaluée est "vraie -true" autrement l'instruction optionnelle bloc2 est exécutée. Le else et le second bloc d'instruction peuvent être omis.
exemple #1:
    // se tourne vers la cible
    if(angle_to_target < 0) // cible à gauche
    {
        // tourne à gaucheleft
        force_right = 100;
        force_left = -5;
    }
    else
    {
        // tourne à droite
        force_right = -5;
        force_left = 100;
    }
Une expression est créée en comparant 2 valeurs utilisant l'un des opérateurs suivants:

||
vrai si au moins l'un des 2 est vrai (correspond au 'ou' Ex. if( value1 || value2 )
&&
vrai si les 2 sont vrais (correspond au 'Et' Ex. if( value1 && value2 )
!=
vrai si les 2 ne sont pas égaux Ex. if( value1 !=& value2 )
==
vrai si les 2 sont égaux Ex. if( value1 ==& value2 )
<=
vrai si le premier est inférieur ou égal au secondEx. if( value1 <=& value2 )
>=
vrai si le premier est supérieur ou égal au secondEx. if( value1 >=& value2 )
<
vrai si le premier est inférieur au secondEx. if( value1 <& value2 )
>
vrai si le premier est supérieur au secondEx. if( value1 >& value2 )

Notez que la comparaison d'égalité est faite avec "==" pour la différencier de l'instruction d'assignation "="
Les Comparaisons peuvent être combinées en utilisant des parenthèses. Utiliser desparenthèses pour déterminer l'ordre d'évaluation à l'intérieur de l'expression.


exemple #2:
// tirer sur la cible
    if((angle_to_target < 5) && (angle_to_target > -5))
    {
        // cible dans 10 degrés
        gun1_fire = 1; // fire primary
        gun2_fire = 1; // fire secondary
    }
Une instructionif peut apparaître à l'intérieur des accolades d'une autre instruction if; de cette façon vous pouvez 'chaîner' plusieurs instructions if

.
exemple #3:
    // contrôle de l'armement
    if((angle_to_target < 5) && (angle_to_target > -5))
    {
        // tire uniquement si la cible est > 5 et< -5
        // et le robot à portée d'armes.
        if(distance_to_target < 2000)
        {
           gun2_fire = 1; // armement secondaire
        }
        if(distance_to_target < 500)
        {
           gun1_fire = 1; // armement primairer
        }
    }

int(x)
Retourne la partie entière de x.
exemple:
value1 = int(543.29); // value1 = 543

max(x,y)
min(x,y)
Retourne le maximum (max) ou le minimum (min) des 2 nombres.
exemple:
value1 = max(5,-8); // value1 = 5
    value1 = min(5,-8); // value1 = -8

pow(x, y)
Retourne la valeur de x élevé à la puissance y. Notez: si x est 0 alors y doit être plus grand que 0 et si x est negatif alors y doit être un entier.
exemple:
value1 = pow(2,3); // value1 = 8

random(x)
Retourne un nombre fractionnaire aléatoirea compris entre 0 et x.
exemple:
value1 = random(6) – 3; // value1 = aun nombre entre –3 et +3

return
Sort de la fonction IA.
exemple:
    if(value1 > 50) { return; } value1 += 1;

sign(x)
Retourne –1 si x est inférieur à 0, 0 if x vaut 0, et +1 si x est plus grand que 0.
exemple:
value1 = sign(-432.32); // value1 = -1

sqrt(x)
Retourne la racine carée de x. Notez: x doit être supérieur ou égal à 0.
exemple: value1 = sqrt(4); // value1 = 2

commandes vectorielles
Les commandes vecctorielles (ces commandes commencent avec"vec_") sont gérées un peu différemment d'une commande normale dans la mesure où chaque argument du vecteur (représenté par u,v ou w) est actuellement 3 valeurs. Par exemple la commande "vec_add(value1,value4)" se résoud comme suit:
    value1 = value1 + value4;
    value2 = value2 + value5;
    value3 = value3 + value6;
Notez: les valeurs ne doivent pas se chevaucher. Par exemple "vec_add(value1,value2)" donnera un résultat indéfini puisque value1 = value1 + value2 et value2 = value2 + value3.

vec_add(v,w)
Ajoute le vecteur w au vecteur v. Le résultat est rangé dans le vecteur v.
exemple:
    // value1 += value4; value2 += value5; value3 += value6
    vec_add(value1,value4);

vec_diff(u,v,w)
Le vecteur u est égal à v –w. Si w et v sont des positions (x,y,z) alors u est un vecteur pointant de w vers v.
exemple:
    // value1,2,3 est un vecteur pointant du robot vers la cible
    vec_diff(value1, target_pos_vec, my_pos_vec);

vec_dist(v,w)
Retourne la distance entre 2 vecteurs.
exemple:
    // value1 = distance_to_target
    value1 = vec_dist(target_pos_vec,my_pos_vec);

vec_dot(v,w)
Retourne le point produit de 2 vecteurs.
exemple:
    // value1 = (value4,5,6) dot (value7,8,9)
    value1 = vec_dot(value4,value7);

vec_inverse(v)
Multiplie toutes les valeurs du vecteur par –1.
exemple:
    // value1 = -value1; value2 = -value2; value3 = -value3;
    vec_inverse(value1);

vec_length(v)
Retourn la longueur de v.
exemple:
    // value1 = distance de mon origine
    value1 = vec_length(my_pos_vec);

vec_normalize(v, x);
Convertit le vecteur v en un vecteur de longueur x. Le vecteur fait face dans la même direction.
exemple:
    // value1,2,3 est maintenant un vecteur de longueur 4
    vec_normalize(value1,4);

vec_rotate(v,w)
Fait tourner v par w.
exemple:
    // fait tourner value1,2,3 par value4,5,6
    vec_roate(value1,value4);

vec_scale(v,x)
Multiplie le vecteur v par la valeur x.
exemple:
    // value1 *= 5; value2 *= 5; value3 *= 5;
    vec_scale(value1,5);

vec_set(v,w)
Copie les valeurs de w dans v.
exemple:
    // value1 = value4; value2 = value5; value3 = value6;
    vec_set(value1,value4);

vec_sub(v,w)
Soustrait w de v.
exemple:
    // value1 -= value4; value2 -= value5; value3 -= value6
    vec_sub(value1,value4);


Variables de Contrôle du Robot
Ce sont des valeurs qui peuvent être utlisées pour contrôler diiférents systèmes (armes, roues et scanners) à l'intérieur du robot ou juste utilisées pour stocker des valeurs. Vous pouvez assigner des valeurs en utilisant des opérateurs ou des fonctions arithmétiques (liste au dessus).

robot_type
La variable robot_type est spéciale puisqu'elle ne peut être mise qu'une fois et dans la fonction robot_load. Cette variable sélectionne le type de chassis robot chassis qui va être utilisé (1,2,3, ou 4). Si aucun type n'est sélectionné ou si la valeur est en dehors de ces 4 chiffres, c'est le chassis 1 qui sera utilisé par défaut.

value1 à value20
Ce sont 20 valeurs utilisateurs définies (variables, registres, etc) dans notre robot que vous pouvez utiliser pour stocker et récupérer des données.
exemple:
    // ceci affecte l'arme primaire toutes les 50 frames.
    value5 += 1; // incremente value5
    if(value5 > 50) { gun1_fire = 1; value5 = 0; }
 
force_left (range: -100 to +100)
force_right (range: -100 to +100)
C'est le pourcentage de force de chaque roue (ou bande de roulement) reçoit. En ajustant la quantité de puissance sur chaque roue séparément vous pouvez effectuer la direction, et la vitesse pour que le robot voyage.

exemple:
    // avance, pleine vitesse
    force_left = 100;
    force_right = 100;
    // tourne à droite(sens des aiguilles d'une montre) rapidement sur place
    force_left = 100;
    force_right = -100;
    // tourne à gauche(sens contraire des aiguilles d'une montre) pendant qu'on avance
    force_left = -25;
    force_right = 100;

apply_brake (ON ou OFF)
Ce drapeau vous permet de vous arrêter rapidement. Quand le frein est mis 'apply_brake = ON;) alors le robot ralentira jusqu'à l'arrêt. Le ralentissement est différent selon les robots (le robot glisseur a des freins très pauvres). Veillez à arrêter vos freins (apply_brake = OFF) avant que vous commenciez à vous déplacer de nouveau.

exemple:
    if(distance_to_target < 500)
    {
    apply_brake = ON;
    }
    else
    {
        apply_brake = OFF;
    }
 
gun1_fire
gun2_fire
Ces deux valeurs vous laissent mettre le feu aux armes primaires(gun2_fire) et secondaires(gun1_fire) du robot. Quand cette valeur est plus grande que 0, le robot essayera de mettre le feu à son arme pendant ce tour. Si l'arme a des munitions et est rechargée (voir les munitions et le statut dans des variables d'environnement ci-dessous) alors l'arme mettra le feu et la valeur stockée dans gun#_file sera réduite d'un.
exemple:

exemple:
    // tire sur la cible lorsqu'elle est près
    if(distance_to_target < 2000)
    {
        gun1_fire = 1; // arme primaire
        gun2_fire = 1; // arme secondaire
    }

FUNC_ONE
FUNC_TWO
FUNC_THREE
FUNC_FOUR
FUNC_FIVE
FUNC_SIX
FUNC_SEVEN
FUNC_EIGHT
Ce sont les fonctions ‘locales’ que vous pouvez utiliser pour écrire vos sous routines qui peuvent être appelées depuis le script principal du robot.
exemple:
    // Desc: tire sur la cible lorsqu'elle est près
    function FUNC_ONE()
    {
        if(distance_to_target < 2000)
        {
            gun1_fire = 1; // arme primaire
            gun2_fire = 1; // arme secondaire
        }
    }
    function AI_ROBOT()
    {
        FUNC_ONE(); // tire sur la cible lorsqu'elle est près
    }
 
 

Variables d'Environment
Les variables d'environnement sont des valeurs en "lecture seule" que vous pouvez employer pour trouver des informations sur certain ' facteurs environnementaux' comme le temps restant, la position de votre cible, etc.

angle_to_target (range: +180 to –180)
C'est le plus petit angle que votre robot devra tourner pour faire face directement à votre cible. Les angles négatifs signifient que la cible est à la droite du robot, des angles positifs sont vers la gauche.

exemple:
    // tourne le robot à gauche(sens des aiguilles d'une montre) si la cible est sur la gauche
    if(angle_to_target > 5) // cible à gauche
    {
        // tourne à gauche
        force_right = 100;
        force_left = -5;
    }
 

damage_taken
La quantité de dommages prise pendant le dernier tour. Ce qui peut être bien utile si vous voulez que votre robot sache quand il a été tiré.
exemple:
    if(damage_taken > 8)
    {
        // run from target
        // …
    }
 

distance_to_target
C'est la distance (en quants) sur une ligne droite à la cible
exemple:
    // fire at target when close
    if(distance_to_target < 2000)
    {
        gun1_fire = 1; // fire primary
        gun2_fire = 1; // fire secondary
    }
 

gun1_ammo
gun2_ammo
Nombre de cartouches dans l'arme primaire (gun1_ammo) ou secondaire (gun2_ammo) . Si la valeur est 999 l'arme a des munitions illimitées (i.e. laser).
exemple:
    // s'éloigner de l'ennemi si nous n'avons plus de munitions
    if((gun1_ammo == 0) && (gun1_ammo == 0))
    {
        // on s'éloigne
    }
 

gun1_status
gun2_status
État actuel de l'arme primaire(gun2_status) ou secondaire(gun1_status) . Nous pouvons avoir les valeurs suivantes : 0 si vide, 1 si prêt à tirer, valeur négative si l'arme est entrain d'être rechargée (où la valeur est le temps en ticks avant que l'arme soit rechargée)
exemple:
    // s'éloigner de l'ennemi si nous avons besoin de recharger
    if(gun1_status < -8)
    {
        // on s'éloigne
    }

los_to_target
C'est une valeur booléenne simple. Est égal à 0 si votre robot n'a pas sa cible en ligne de mire, à 1 sinon. Ligne de mire signifie que le robot peut voir la cible si elle lui fait face (e.g. il n'y a aucun mur entre le robot et sa cible).
exemple:
    if(los_to_target == 1) // nous avons la ligne de mire
    {
        // fire guns
    }

my_pos_vec
target_pos_vec
C'est un vecteur (x, y, z) contenant la position actuelle de votre robot (my_pos_vec) ou le robot cible (target_pos_vec) relative au point central d'arène. Chaque valeur dans le vecteur peut être consultée individuellement en utilisant a.x. y, ou. z ou peut être employée comme argument dans une commande de vecteur.
exemple:
    // fait que value1 = distance_to_target
    value1 = vec_dist(target_pos_vec,my_pos_vec);


my_rot_vec
target_rot_vec
C'est un vecteur de rotation (pan, tilt, roll) contenant l'orientation courante de votre robot (my_rot_vec _ ou le robot cible (target_rot_vec) en degrés. L'angle fera partie toujours de l'étendue -180 à +180. Chaque valeur peut être consultée individuellement en utilisant a.pan, .tilt ou .roll ou peut être employé comme argument dans une
exemple:
    // rotate to match target pan
    if(my_rot_vec.pan > target _rot_vec.pan)
    {
        // turn right
        force_right = -25;
        force_left = 25;
    }
    else
    {
        // turn left
        force_right = 25;
        force_left = -25;
    }
 
my_speed
C'est la vitesse du robot en quants par tick (qpt).
exemple:
    // Accélère si sous une certaine vitesse
    if(my_speed < 15)
    {
        // speed up
        force_right = 100;
        force_left = 100;
    }

range_type
range_dist
range_angle
Chaque robot est equipé d'une "tête chercheuse laser" (laser range finder que j'ai du mal à traduire) pointant vers l'avant. Cette "tête chercheuse" sent des obstacles devant le robot jusqu'a 2000quants et renvoie la distance à cet objet dans la valeur range_dist. Le 'type' de l'objet est également identifié et stocké dans range_type (1 pour un objet plein comme un mur, 2 si c'est un autre robot, 0 si rien n'est trouvé).
La valeur mise dans range_angle dépend de l'objet scané. Si l'objet est un autre robot, range_angle est mis à la valeur courante de ce robot. Si l'objet est un mur, range_angle est placé à l'angle auquel votre robot devrait faire face pour se diriger directement loin du mur.
exemple:
    // avoid walls
    if((range_type == 1) && (range_dist < 750))
    {
        value1 = range_angle; // value1 is the angle to turn to
    }

time_remaining
C'est le temps (en ticks) passé dans ce match.
exemple:
    // ne pas utiliser l'arme primaire pendant la première moitié du match
    if(time_remaining > 60*16) // 60 seconds * 16 ticks/second
    {
        gun1_fire = 0; // ne pas tirer avec l'arme primaire
    }

time_delta
C'est le nombre de ticks qui a passé depuis le dernier tour.
exemple:
    // arme l'arme primaire toutes les 5 secondes.
    value5 += time_delta; // increament value5
    if(value5 > 80) { gun1_fire = 1; value5 = 0; } // note: 80 = 5(seconds)*16(ticks/second)
 
 
 

Annexe B: Chassis Robot

Il y a quatre types différents de châssis de robot à choisir . Chaque châssis de robot a ses propres forces et faiblesses. Comme programmeur du robot, il vous appartient d'employer ces forces et de surmonter les faiblesses pour bienaller à la victoire finale.

Chassis #1

Nom:

Tank

Numéro du Modèle:

3x0A45C973

Armure:

Forte

Vitesse:

Lent

Arme #1:

Canon

Arme #2:

Mitrailleuse

Desc:

C'est le robot le plus lourd qui puisse concourir. Son canon a la puissance saisissante de longue portée mais il est difficile de frapper les cibles rapidement en mouvement avec. Le robot se déplace très lentement, mais a plus d'armure que n'importe quel autre robot.

Trucs:

Une fois que vous apprenez comment mener votre cible (ou attendre jusqu'à ce que votre cible ait frappé quelque chose), le canon de ce robot peut faire du bon travail.



Chassis #2

Nom:

Launcher

Numéro du Modèle:

3x0A455432

Armure:

Moyenne

Vitesse:

Moyenne/lente

Arme #1:

lanceur de roquettes

Arme #2:

Mitrailleuse

Desc:

La roquette laisseespérer une bonne issue avec ce robot, mais des robots rapides peuvent toujours éviter d'être frappés si on leur donnes assez de temps pour se déplacer.

Truc:

La roquette est vraiment bonne sur des distances moyennes. Trop loin et vous risquez de louper la cible, trop près et vous risquez de subir les dégâts colatéraux.



Chassis #3

Nom:

Fast Attack

Numéro du Modèle:

3x0A458E27

Armure:

Légère

Vitesse:

Très rapideFast

Arme #1:

Mitrailleuse

Arme #2:

Mitrailleuse

Desc:

Ce robot a les armes et l'armure les plus légères mais sa grande vitesse le fait être favori des foules. Ceci peut être le robot le plus difficile à programmer puisque les mitrailleuses exigent de frapper les cibles de multiples fois(tout en évitant d'être frappé).

Truc:

Pleine vitesse et évitez de frapper des murs et d'autres robots. Si vous vous "bloquez" avec un autre robot vous serez bientôt finis.



Chassis #4

Noae:

Hover

Numéro du Modèle:

3x0A4512EA

Armure:

Moyenne

Vitesse:

Rapide

Arme #1:

Laser

Arme #2:

Laser

Desc:

Les doubles lasers rendent ce robot effrayant, mais les longs temps de recharge sont une vraie faiblesse.

Truc:

Faites le compte de vos projectiles et essayer d'éviter d'être frappé tandis que vous rechargez



 

 

Annexe C: Système d'arme

lanceur de roquette
Les roquettes sont lentes mais peuvent atteindre leur cibleare slow but they can home in on their targets.
Lorsque vous utilisez cette arme assurez-vous que vous êtes assez loin de votre cible si vous ne voulez pas que votre robot ne prenne des dommages avec le souffle.


Laser
Le laser est une grande arme en raison de sa portée et de son offre illimitée de munitions. Puisque le faisceau se déplace à la vitesse de la lumière inutile de vous approcher de votre cible. Le revers de la médaille est qu'après chaque tir le condensateur du laser à besoin de se recharger ce qui fait que le laser ne peut tirer qu'une fois toutes les 2 secondes.

Mitrailleuse
la mitrailleuse tire plusieurs petites balles à haute vitesse par seconde. Les dommages par projectile sont minimaux mais s'ajoutent rapidement.

Canon

Les boulet de canon font beaucoup de dommages mais c'est l'arme la plus difficile à frapper avec. Le canon et plus lent que des balle de mitrailleuse et n'atteint pas forcément sa cible comme les roquettes mais elles font moins de dommages de souffle aussi ils peuvent être employés à des distances plus courtes.

 

Annexe D: Physique des Robots

Quoique les robots soient très différents dans leur taille, poids, et méthodes d'entraînement, ils suivent les mêmes règles de base pour la manoeuvre. Chaque robot a deux 'roues' commandée indépendamment (bandes de roulement, coussin d'air, etc..) situé de chaque côté du robot. En appliquant des forces aux roues (en utilisant force_right et force_left) vous pouvez faire aller le robot vers l'avant, vers l'arrière, tourner en place, ou toute combinaison de ce qui précède (i.e. avancez tout en tournant dans le sens des aiguilles d'une montre).
Se déplacer vers l'avant ou vers l'arrière est très simple, appliquez simplement une force égale aux deux roues:


    // aller de l'avant à demi vitesse
    force_left = 50;
    force_right = 50;

Pour tourner sur place appliquez des forces opposées sur chaque roue:

    // rotation sur place dans le sens des aiguilles d'une montre
    force_left = 25;
    force_right = -25;

S'il y a une différence de force sur les 2 roues, le robot tournera du coté de la roue la moins puissante:

    // aller de l'avant et vers la droite
    force_left = 75;
    force_right = 50;
 
Rappelez-vous, chaque robot se comporte différent en raison de sa masse, sa puissance et sa taille. Tandis que les robots légers peuvent manoeuvrer rapidement les plus lourd se déplacent beaucoup plus lentement. Les robots avec une bande de roulement sont plus plus longs à prendre leur vitesse tandis que les robots à roues se déplacent tellement rapidement qu'il est difficile de les empêcher d'aller dans des murs.