How to use

IBattleListener

in

robocode.control.events

  public void onBattleError(BattleErrorEvent event) {
    for (IBattleListener listener : listeners) {
      try {
        listener.onBattleError(event);
      } catch (Throwable ex) {
        Logger.realErr.println(listener.getClass() + " " + ex.getMessage());
      }
    }
  }
}

public void onBattleMessage(BattleMessageEvent event) {
  for (IBattleListener listener : listeners) {
    try {
      listener.onBattleMessage(event);
    } catch (Throwable ex) {
      logError("onBattleMessage " + listener.getClass(), ex);
    }
  }
}

public void onBattleCompleted(BattleCompletedEvent event) {
  for (IBattleListener listener : listeners) {
    try {
      listener.onBattleCompleted(event);
    } catch (Throwable ex) {
      logError("onBattleCompleted " + listener.getClass(), ex);
    }
  }
}

public void onRoundStarted(RoundStartedEvent event) {
  for (IBattleListener listener : listeners) {
    try {
      listener.onRoundStarted(event);
    } catch (Throwable ex) {
      logError("onRoundStarted " + listener.getClass(), ex);
    }
  }
}

public void onRoundEnded(RoundEndedEvent event) {
  for (IBattleListener listener : listeners) {
    try {
      listener.onRoundEnded(event);
    } catch (Throwable ex) {
      logError("onRoundEnded " + listener.getClass(), ex);
    }
  }
}

public void onBattlePaused(BattlePausedEvent event) {
  for (IBattleListener listener : listeners) {
    try {
      listener.onBattlePaused(event);
    } catch (Throwable ex) {
      logError("onBattlePaused " + listener.getClass(), ex);
    }
  }
}

public void onBattleResumed(BattleResumedEvent event) {
  for (IBattleListener listener : listeners) {
    try {
      listener.onBattleResumed(event);
    } catch (Throwable ex) {
      logError("onBattleResumed " + listener.getClass(), ex);
    }
  }
}

public void onBattleFinished(BattleFinishedEvent event) {
  for (IBattleListener listener : listeners) {
    try {
      listener.onBattleFinished(event);
    } catch (Throwable ex) {
      logError("onBattleFinished " + listener.getClass(), ex);
    }
  }
}

public void onTurnEnded(TurnEndedEvent event) {
  for (IBattleListener listener : listeners) {
    try {
      listener.onTurnEnded(event);
    } catch (Throwable ex) {
      logError("onTurnEnded " + listener.getClass(), ex);
    }
  }
}

public void onBattleStarted(BattleStartedEvent event) {
  for (IBattleListener listener : listeners) {
    try {
      listener.onBattleStarted(event);
    } catch (Throwable ex) {
      logError("onBattleStarted " + listener.getClass(), ex);
    }
  }
}

public static void logError(String s) {
  if (logListener == null) {
    if (System.getProperty("logErrors", "true").equalsIgnoreCase("true")) {
      s = StringUtil.toBasicLatin(s);
      realErr.println(s);
    }
  } else {
    logListener.onBattleError(new BattleErrorEvent(s));
  }
}

public static void logMessage(String s, boolean newline) {
  if (logListener == null) {
    if (System.getProperty("logMessages", "true").equalsIgnoreCase("true")) {
      s = StringUtil.toBasicLatin(s);
      if (newline) {
        realOut.println(s);
      } else {
        realOut.print(s);
        realOut.flush();
      }
    }
  } else {
    synchronized (logBuffer) {
      if (!HiddenAccess.isSafeThread()) {
        // we just queue it, to not let unsafe thread travel thru system
        logBuffer.append(s);
        logBuffer.append("\n");
      } else if (newline) {
        logListener.onBattleMessage(new BattleMessageEvent(logBuffer + s));
        logBuffer.setLength(0);
      } else {
        logBuffer.append(s);
      }
    }
  }
}