Programmer un robot, lire une carte, comprendre un tour.

Principe

Chaque robot possede un script. Au debut de son tour, le moteur execute la fonction d'entree my_turn, ou son alias localise mon_tour. Les actions appelees dans ce script consomment des points d'action, modifient la position du robot, attaquent, soignent, lisent la carte ou changent le terrain.

Exemple minimal :

my_turn {
  say("Ready")
  move_forward()
  sword_swing()
}

Tour de jeu

• Le robot commence son tour avec ses points d'action disponibles.
• Les actions sont executees dans l'ordre du script.
• Certaines actions coutent plus cher si elles sont repetees dans le meme tour, par exemple move_forward, move_backward, jump et dash.
• Si une action est impossible, le moteur peut depenser les AP puis journaliser un avertissement de gameplay selon l'action.
• Les getters comme get_pos_x() ou scan_tile(x, y) ne sont pas des actions de combat : ils servent a lire l'etat du jeu.

Carte et tuiles

Les cartes utilisent des codes courts :

Programmer son robot

Utilisez my_turn comme point d'entree :

my_turn { if (scan_tile(1, 0) = "enemy") { sword_swing() } else { move_forward() } } Vous pouvez creer des fonctions :

my_turn {
  if (scan_tile(1, 0) = "enemy") {
    sword_swing()
  } else {
    move_forward()
  }
}

def attack_if_close {
  if (scan_tile(1, 0) = "enemy") {
    sword_swing()
  }
}

my_turn {
  attack_if_close()
}

Lire l'environnement

Les blocs de perception permettent de prendre des decisions :

• get_pos_x() et get_pos_y() donnent votre position.
• scan_tile(x, y) renvoie empty, ally, enemy, obstacle ou out_of_bounds.
• is_tile_empty(x, y) indique si une tuile peut etre consideree vide.
• get_tile_type(x, y) renvoie le code de tuile comme FL ou WL.
• get_tile_occupant_type(x, y) renvoie ally, enemy, unknown_entity, none, obstacle ou out_of_bounds.
• get_tile_occupant_id(x, y) renvoie l'id visible de l'occupant, ou une chaine vide.
• get_entity_x(id), get_entity_y(id), get_entity_health(id), is_entity_alive(id) et get_entity_team(id) lisent une entite connue.

Actions principales

• Mouvement : move_forward, move_backward, turn, face_north, face_south, face_east, face_west, jump, dash.
• Attaque : sword_swing, spear, kick, pistol, grenade, bazooka, lighter, fire_wave, tazer, lazer, ultra_lazer.
• Support : heal, cooling_system, repair_system, say.
• Terrain : place_trap, dig.

Alias localises

Les exemples historiques de cette page gardent les noms d'action anglais, mais le backend accepte aussi des alias ASCII pour les scripts de joueurs :

La reference complete est dans Reference Blocs.

• Francais : mon_tour, fonction, repeter, tourner, avancer, reculer, regarder_nord, charger, lancer_grenade, soigner, creuser, dire.
• Espagnol : mi_turno, funcion, repetir, girar, avanzar, retroceder, mirar_norte, embestir, lanzar_granada, curar, cavar, decir.

Effets de statut

• overheat inflige des degats pendant plusieurs tours et peut etre retire avec cooling_system().
• short-circuit reduit les AP et peut etre retire avec repair_system().

Conseils

• Utilisez say("message") pour deboguer visuellement une strategie.
• Testez d'abord des scripts courts.
• Lisez la carte avec les getters avant de lancer une action risquee.
• Gardez assez d'AP pour vous repositionner apres une attaque.
• Les actions a zone ou projectile peuvent toucher plusieurs cases selon leur pattern.

Point d'entree

Un script doit contenir une seule fonction d'entree :

my_turn { move_forward() } Aliases d'entree acceptes :

• my_turn
• mon_tour
• mein_zug
• mi_turno
• minha_vez

my_turn {
  move_forward()
}

Fonctions

Les fonctions peuvent etre declarees avec def, function, definir, définir, fonction, funktion, funcion, función ou função.

def step_twice { move_forward() move_forward() } my_turn { step_twice() } Les fonctions peuvent recevoir des parametres :

def step_twice {
  move_forward()
  move_forward()
}

my_turn {
  step_twice()
}

def speak(message) {
  say(message)
}

my_turn {
  speak("Hello")
}

Variables

Une variable est creee ou remplacee avec =.

my_turn {
  x = get_pos_x()
  y = get_pos_y()
  say("Position checked")
}

Conditions

Les mots-cles reconnus sont if, si, wenn et else, sinon, sonst, sino, senão.

my_turn {
  if (scan_tile(1, 0) = "enemy") {
    sword_swing()
  } else {
    move_forward()
  }
}

Boucles

repeat repete un bloc un nombre fixe de fois.

my_turn { repeat(2) { move_forward() } } while repete tant qu'une condition reste vraie.

my_turn { while (get_pos_x() < 3) { move_forward() } } Aliases de boucle :

• repeat, repeter, répéter, wiederhole, repetir
• while, tantque, solange, mientras, enquanto

my_turn {
  repeat(2) {
    move_forward()
  }
}

my_turn {
  while (get_pos_x() < 3) {
    move_forward()
  }
}

Retour de fonction

return, retourne, retour, zurück, devuelve et retorna renvoient une valeur.

def enemy_ahead {
  return scan_tile(1, 0) = "enemy"
}

Expressions

LiteralScraps accepte :

• nombres entiers ou decimaux
• chaines entre guillemets doubles
• variables
• appels de fonctions
• parentheses
• operations +, -, *, /
• comparaisons >, <, =, !=, >=, <=
• logique booleenne avec & et |

Erreurs frequentes

• Plus d'une fonction d'entree dans le meme script.
• Appeler une action inconnue.
• Appeler un getter avec le mauvais nombre d'arguments.
• Appeler say() sans message.
• Appeler grenade avec un seul argument : elle accepte grenade() ou grenade(x, y).
• Utiliser une syntaxe for : le token existe dans la grammaire, mais la regle for n'est pas active dans le parser actuel.

Blocs de langage

Getters et perception

Actions de mouvement

Actions offensives

Support et terrain

Effets

Regles importantes

• Les actions non throwable n'acceptent pas de coordonnees cible.
• Les throwables avec pattern throw-point, actuellement grenade, acceptent 0 ou 2 arguments.
• Les degats allies dependent de combatOptions.friendlyFire; l'auto-hit depend des parametres de l'action.
• Les getters sont journalises comme informations, pas comme actions.