Introduction au combat Robotisé:

Pour commencer :

Observation d'un match

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

"Connaître le Score"

Annexe A: Commandes et Variables IA

Commandes

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.

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.

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é.

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.

   robot_type = 1; // utilise robot #1

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

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:

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.

= (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:

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)
 
 
 

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.

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.