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 it works?

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 how does it look like in a 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):

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

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 lenght 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);
}

See Also

• Movement
• Movement Implementations
• Stop And Go