Stop And Go Tutorial

What is Stop And Go?

Stop And Go is a very popular movement among NanoBots and MicroBots. It's extremely powerful against simple targeting methods as Head-On Targeting, Linear Targeting or Circular Targeting, however, it's extremely useless against advanced targetings for example Pattern Matching guns. For more details take a look at the 'official' Stop And Go page.

But how does it work?

Generally, Stop And Go means moving a bit when the enemy fires and stopping before its next firing. It confuses Linear Targeting and Circular Targeting, because at the time of firing our bot stands still, so they work as Head-On Targeting which is useless against all one-way movements.

Okay, but what does it look like in code?

Now I show you how I implemented it in my nanos.

First and foremost, the most important part of Stop And Go is keeping track of the enemy's previous energy. The difference between the previous and the actual energy state gives the necessary data to decide whether the enemy fired or not. So you should create a global variable for it. Of course, you should update it every turn you see the enemy.

.
.
.
static double prevEnergy = 100.0;
.
.
.
public void onScannedRobot(ScannedRobotEvent e){

//energy monitoring
prevEnergy = e.getEnergy();
}

Now comes the energy monitoring. When a robot fires, it loses energy equal to the power of the bullet it fired. So if you realise an energy drop >0 and <=3, the enemy fired. I found 2 modes to check this code size friendly. First is the conditional approachment (notice that the getDistanceRemaining is essential for Stop And Go):

.
.
.
static double prevEnergy = 100.0;
.
.
.
public void onScannedRobot(ScannedRobotEvent e){

  //energy monitoring
  if(getDistanceRemaining()==0.0 && prevEnergy-e.getEnergy()>0.0){
    setAhead(36*direction);
  }
  prevEnergy = e.getEnergy();
}

The another mode is implemented in the movement code:

if(getDistanceRemaining()==0.0){
 setAhead(direction*36*Math.max(0,Math.signum(prevEnergy-e.getEnergy())));
}

The choice is yours and of course, the circumstances. I used only >0 condition, because it's more than enough for most robots. Obviously, you can expand this energy monitoring with several adjustments. For example, you can add <=3 to the condition. This avoids the little mistakes in the movement when your enemy continually hits you.( anyway your robot would think that the enemy hasn't fired.) Then you can check wall-hitting which has a similar affect on energy. To be a bit more effective against other targeting methods, you can vary the length of the movement. Playing with heading is also a good idea. (approaching, retreating)

Even less CodeSize

However, this kind of StopNGo can be squeezed even more. For example, the energy monitoring condition can be shrinked like this:

if(prevEnergy > (prevEnergy = e.getEnergy()) && getDistanceRemaining() == 0.0){
 ...movement code...
}

If you move only short distances (e.g. 30-40px) you can leave out the getDistanceRemaining() condition.

if(prevEnergy > (prevEnergy = e.getEnergy())){
 // ...movement code...
}

You can also play with the direction variable. In many cases you can simply mix the moving distance and the direction variable together. For example, if your movement distance is 36px, you can simply initalize direction 36. Then the code would be this:

if(prevEnergy > (prevEnergy = e.getEnergy())){
 setAhead(direction);
}

Variable Length

It is critically important that your robot stops moving before the next enemy bullet is actually fired, or else its movement will get slaughtered by linear and circular targeting. It's also a good idea to move as much as you can before you have to stop, because the enemy's gun isn't always perfectly accurate, among other reasons. It is important to note that the energy drop will be detected two ticks after the enemy bullet is fired, so the movements will have to be shorter than one would expect. Due to the way gun heat works, the maximum movement length before the enemy fires again will be dependent on the enemy bullet power. Further complicating things, you will have to take into account your robot's acceleration and deceleration.

Here are the maximum movement lengths for different enemy bullet powers, along with a tick-by-tick examination and gun heat formulas:

Enemy Bullet Power 0.0 = (((0.0 / 5) + 1) / 0.1) - 2 = 8  = 1 + 2 + 3 + 4 + 5 + 6 + 4 + 2                         = 27 pixels

Enemy Bullet Power 0.5 = (((0.5 / 5) + 1) / 0.1) - 2 = 9  = 1 + 2 + 3 + 4 + 5 + 6 + 6 + 4 + 2                     = 33 pixels

Enemy Bullet Power 1.0 = (((1.0 / 5) + 1) / 0.1) - 2 = 10 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 5 + 3 + 1                 = 37 pixels

Enemy Bullet Power 1.5 = (((1.5 / 5) + 1) / 0.1) - 2 = 11 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 6 + 4 + 2             = 48 pixels

Enemy Bullet Power 2.0 = (((2.0 / 5) + 1) / 0.1) - 2 = 12 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 8 + 6 + 4 + 2         = 56 pixels

Enemy Bullet Power 2.5 = (((2.5 / 5) + 1) / 0.1) - 2 = 13 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 8 + 8 + 6 + 4 + 2     = 64 pixels

Enemy Bullet Power 3.0 = (((3.0 / 5) + 1) / 0.1) - 2 = 14 = 1 + 2 + 3 + 4 + 5 + 6 + 7 + 8 + 8 + 8 + 8 + 6 + 4 + 2 = 72 pixels

If you are worried about codesize, you can use an approximation like this from Cotillion 0.1:

((3 + (int)(/*<enemy energy drop>*/*1.999999)) << 3 )

See Also

• Movement
• Movement Implementations
• Stop And Go