Communication

Your program talks to the game through two devices that every robot has:

• The emitter sends messages to the game. It does not need to be enabled.
• The receiver gets messages from the game. Enable it like a sensor.

Each section below is a complete program for the starter robot. All the messages are listed in the Message Reference.

Scoring wall tokens

To score a letter victim or a cognitive target, the robot must:

1. Stop for more than 1 second close to the token. Erebus ignores the report if the robot has moved in the last second.
2. Send the position and type of the token: X and Z in centimetres, and the type as one letter.

Wall token	Type
Letter victim Φ (harmed)	H
Letter victim Ψ (stable)	S
Letter victim Ω (unharmed)	U
Cognitive target, sum 0 (Flammable Gas)	F
Cognitive target, sum 1 (Poison)	P
Cognitive target, sum 2 (Corrosive)	C
Cognitive target, sum 3 (Organic Peroxide)	O

The types are letters, even though victims show symbols since 2026. The GPS gives metres, so multiply by 100.

Python

from controller import Robot
import struct

robot = Robot()
timeStep = int(robot.getBasicTimeStep())

emitter = robot.getDevice("emitter")  # Always on the robot. It does not need to be enabled.
gps = robot.getDevice("gps")
gps.enable(timeStep)
leftWheel = robot.getDevice("left wheel motor")
rightWheel = robot.getDevice("right wheel motor")
leftWheel.setPosition(float("inf"))
rightWheel.setPosition(float("inf"))

def wait(seconds):
    start = robot.getTime()
    while robot.step(timeStep) != -1:
        if robot.getTime() - start >= seconds:
            break

def report(tokenType):
    # 1. Stop for more than 1 second
    leftWheel.setVelocity(0)
    rightWheel.setVelocity(0)
    wait(1.2)
    # 2. Send the position in centimeters, and the type as one letter
    x, _, z = gps.getValues()
    message = struct.pack("i i c", int(x * 100), int(z * 100), tokenType.encode())
    emitter.send(message)
    robot.step(timeStep)

report("H")  # Reports a harmed victim (Φ) where the robot is
print("Reported")

C/C++

#include <iostream>
#include <cmath>
#include <cstring>
#include <webots/Robot.hpp>
#include <webots/Emitter.hpp>
#include <webots/GPS.hpp>
#include <webots/Motor.hpp>

using namespace webots;

Robot *robot;
Emitter *emitter;
GPS *gps;
Motor *leftWheel, *rightWheel;
int timeStep;

void wait(double seconds) {
  double start = robot->getTime();
  while (robot->step(timeStep) != -1) {
    if (robot->getTime() - start >= seconds)
      break;
  }
}

void report(char tokenType) {
  // 1. Stop for more than 1 second
  leftWheel->setVelocity(0);
  rightWheel->setVelocity(0);
  wait(1.2);
  // 2. Send the position in centimeters, and the type as one letter
  int position[2] = {(int)(gps->getValues()[0] * 100), (int)(gps->getValues()[2] * 100)};
  char message[9];
  memcpy(message, position, sizeof(position));
  message[8] = tokenType;
  emitter->send(message, sizeof(message));
  robot->step(timeStep);
}

int main() {
  robot = new Robot();
  timeStep = (int)robot->getBasicTimeStep();

  emitter = robot->getEmitter("emitter"); // Always on the robot. It does not need to be enabled.
  gps = robot->getGPS("gps");
  gps->enable(timeStep);
  leftWheel = robot->getMotor("left wheel motor");
  rightWheel = robot->getMotor("right wheel motor");
  leftWheel->setPosition(INFINITY);
  rightWheel->setPosition(INFINITY);

  report('H'); // Reports a harmed victim (Φ) where the robot is
  std::cout << "Reported" << std::endl;

  delete robot;
  return 0;
}

The robot must be on the same side of the wall as the token, and both the robot and the position you send must be close to it. The rules require at most half a tile, so aim for that. Erebus v26.1 checks a distance of 9 cm.

Run this program at the start of world1.wbt: there is no token there, so the history of the control window shows Misidentification of Victim -5. A wrong report, including a report of a fake, costs 5 points, and each token can only be scored once.

Lack of progress

When the robot is stuck, a lack of progress moves it back to the last checkpoint and costs 5 points. It happens automatically after 20 seconds without moving, and your program can also call it by sending L. Each time, the game sends L to the robot, so that your program knows its position has changed.

Python

from controller import Robot
import struct

robot = Robot()
timeStep = int(robot.getBasicTimeStep())

emitter = robot.getDevice("emitter")
receiver = robot.getDevice("receiver")
receiver.enable(timeStep)  # The receiver must be enabled

askedAt = None
while robot.step(timeStep) != -1:
    # Call a lack of progress once, after 2 seconds
    if askedAt is None and robot.getTime() > 2:
        emitter.send(struct.pack("c", b"L"))
        askedAt = robot.getTime()

    # Listen for messages from the game
    while receiver.getQueueLength() > 0:
        data = receiver.getBytes()
        if len(data) == 1 and data == b"L":
            print("Lack of progress! The robot is back at the last checkpoint.")
        receiver.nextPacket()

C/C++

#include <iostream>
#include <webots/Robot.hpp>
#include <webots/Emitter.hpp>
#include <webots/Receiver.hpp>

using namespace webots;
using namespace std;

int main() {
  Robot *robot = new Robot();
  int timeStep = (int)robot->getBasicTimeStep();

  Emitter *emitter = robot->getEmitter("emitter");
  Receiver *receiver = robot->getReceiver("receiver");
  receiver->enable(timeStep); // The receiver must be enabled

  bool asked = false;
  while (robot->step(timeStep) != -1) {
    // Call a lack of progress once, after 2 seconds
    if (!asked && robot->getTime() > 2) {
      char message = 'L';
      emitter->send(&message, 1);
      asked = true;
    }

    // Listen for messages from the game
    while (receiver->getQueueLength() > 0) {
      const char *data = (const char *)receiver->getData();
      if (receiver->getDataSize() == 1 && data[0] == 'L')
        cout << "Lack of progress! The robot is back at the last checkpoint." << endl;
      receiver->nextPacket();
    }
  }

  delete robot;
  return 0;
}

The receiver can get different messages, so check the length of each one before reading it, as in the example.

Game information

Send G to get the score and the time left. The game replies with a 16-byte message: the letter G, the score, the game time left and the real time left, in seconds.

Python

from controller import Robot
import struct

robot = Robot()
timeStep = int(robot.getBasicTimeStep())

emitter = robot.getDevice("emitter")
receiver = robot.getDevice("receiver")
receiver.enable(timeStep)

lastAsked = 0
while robot.step(timeStep) != -1:
    # Ask for the game information once a second
    if robot.getTime() - lastAsked > 1:
        emitter.send(struct.pack("c", b"G"))
        lastAsked = robot.getTime()

    while receiver.getQueueLength() > 0:
        data = receiver.getBytes()
        if len(data) == 16:  # The game information is 16 bytes long
            _, score, timeLeft, realTimeLeft = struct.unpack("c f i i", data)
            print("Score:", round(score, 2), "Time left:", timeLeft, "s", "Real time left:", realTimeLeft, "s")
        receiver.nextPacket()

C/C++

#include <iostream>
#include <cstring>
#include <webots/Robot.hpp>
#include <webots/Emitter.hpp>
#include <webots/Receiver.hpp>

using namespace webots;
using namespace std;

int main() {
  Robot *robot = new Robot();
  int timeStep = (int)robot->getBasicTimeStep();

  Emitter *emitter = robot->getEmitter("emitter");
  Receiver *receiver = robot->getReceiver("receiver");
  receiver->enable(timeStep);

  double lastAsked = 0;
  while (robot->step(timeStep) != -1) {
    // Ask for the game information once a second
    if (robot->getTime() - lastAsked > 1) {
      char message = 'G';
      emitter->send(&message, 1);
      lastAsked = robot->getTime();
    }

    while (receiver->getQueueLength() > 0) {
      const char *data = (const char *)receiver->getData();
      if (receiver->getDataSize() == 16 && data[0] == 'G') { // The game information is 16 bytes long
        float score;
        int timeLeft, realTimeLeft;
        memcpy(&score, data + 4, 4);
        memcpy(&timeLeft, data + 8, 4);
        memcpy(&realTimeLeft, data + 12, 4);
        cout << "Score: " << score << " Time left: " << timeLeft << " s Real time left: " << realTimeLeft << " s" << endl;
      }
      receiver->nextPacket();
    }
  }

  delete robot;
  return 0;
}

The game time runs faster in swamps, and the game ends when either time runs out. Use both to know when to head back to the start.

Ending the game

Send E to end the game. If the robot is on the starting tile and has identified at least one wall token, it gets the 10% exit bonus.

Python

from controller import Robot
import struct

robot = Robot()
timeStep = int(robot.getBasicTimeStep())
emitter = robot.getDevice("emitter")

robot.step(timeStep)
print("Ending the game")
# Ends the game. Send it on the starting tile, after identifying a token, to get the exit bonus.
# The game stops your program right after this message.
emitter.send(struct.pack("c", b"E"))
robot.step(timeStep)

C/C++

#include <iostream>
#include <webots/Robot.hpp>
#include <webots/Emitter.hpp>

using namespace webots;

int main() {
  Robot *robot = new Robot();
  int timeStep = (int)robot->getBasicTimeStep();
  Emitter *emitter = robot->getEmitter("emitter");

  robot->step(timeStep);
  std::cout << "Ending the game" << std::endl;
  // Ends the game. Send it on the starting tile, after identifying a token, to get the exit bonus.
  // The game stops your program right after this message.
  char message = 'E';
  emitter->send(&message, 1);
  robot->step(timeStep);

  delete robot;
  return 0;
}

Caution

The game ends wherever the robot is when it sends E, and the robot cannot continue. Make sure it has returned to the starting tile first, and has submitted its map.

Next, learn to tell the tokens apart in Wall Tokens.