示例#1
0
 private void cleanup() {
   cleanupStreams();
   if (tempFile != null && tempFile.exists()) {
     if (tempFile.delete() == false) {
       Logger.logError("Could not delete temp file");
     }
     tempFile = null;
   }
   recordInfo = null;
 }
示例#2
0
 private void createTempFile() {
   try {
     if (tempFile == null) {
       tempFile = File.createTempFile("robocode-battle-records", ".tmp");
       tempFile.deleteOnExit();
     } else {
       if (!tempFile.delete()) {
         Logger.logError("Could not delete temp file");
       }
       if (!tempFile.createNewFile()) {
         throw new Error("Temp file creation failed");
       }
     }
   } catch (IOException e) {
     logError(e);
     throw new Error("Temp file creation failed", e);
   }
 }
  private void printResultsData(BattleCompletedEvent event) {
    // Do not print out if no result file has been specified and the GUI is enabled
    if ((setup.resultsFilename == null
        && (!setup.exitOnComplete || windowManager.isGUIEnabled()))) {
      return;
    }

    PrintStream out = null;
    FileOutputStream fos = null;

    try {
      if (setup.resultsFilename == null) {
        out = Logger.realOut;
      } else {
        File f = new File(setup.resultsFilename);

        try {
          fos = new FileOutputStream(f);
          out = new PrintStream(fos);
        } catch (IOException e) {
          Logger.logError(e);
        }
      }
      if (out != null) {
        BattleResultsTableModel resultsTable =
            new BattleResultsTableModel(
                event.getSortedResults(), event.getBattleRules().getNumRounds());

        ByteArrayOutputStream baos = new ByteArrayOutputStream();

        resultsTable.print(new PrintStream(baos));
        out.append(StringUtil.toBasicLatin(baos.toString()));
      }
    } finally {
      FileUtil.cleanupStream(out);
      FileUtil.cleanupStream(fos);
    }
  }
示例#4
0
  public void loadRecord(String recordFilename, BattleRecordFormat format) {
    FileInputStream fis = null;
    BufferedInputStream bis = null;
    ZipInputStream zis = null;
    ObjectInputStream ois = null;
    InputStream xis = null;

    FileOutputStream fos = null;
    BufferedOutputStream bos = null;
    ObjectOutputStream oos = null;

    try {
      createTempFile();
      fis = new FileInputStream(recordFilename);
      bis = new BufferedInputStream(fis, 1024 * 1024);

      if (format == BattleRecordFormat.BINARY) {
        ois = new ObjectInputStream(bis);
      } else if (format == BattleRecordFormat.BINARY_ZIP) {
        zis = new ZipInputStream(bis);
        zis.getNextEntry();
        ois = new ObjectInputStream(zis);
      } else if (format == BattleRecordFormat.XML_ZIP) {
        zis = new ZipInputStream(bis);
        zis.getNextEntry();
        xis = zis;
      } else if (format == BattleRecordFormat.XML) {
        xis = bis;
      }
      if (format == BattleRecordFormat.BINARY || format == BattleRecordFormat.BINARY_ZIP) {
        recordInfo = (BattleRecordInfo) ois.readObject();
        if (recordInfo.turnsInRounds != null) {
          fos = new FileOutputStream(tempFile);
          bos = new BufferedOutputStream(fos, 1024 * 1024);
          oos = new ObjectOutputStream(bos);

          for (int i = 0; i < recordInfo.turnsInRounds.length; i++) {
            for (int j = recordInfo.turnsInRounds[i] - 1; j >= 0; j--) {
              try {
                ITurnSnapshot turn = (ITurnSnapshot) ois.readObject();

                oos.writeObject(turn);
              } catch (ClassNotFoundException e) {
                logError(e);
              }
            }
          }
        }
      } else {
        final RecordRoot root = new RecordRoot();

        fos = new FileOutputStream(tempFile);
        bos = new BufferedOutputStream(fos, 1024 * 1024);
        root.oos = new ObjectOutputStream(bos);
        XmlReader.deserialize(xis, root);
        if (root.lastException != null) {
          logError(root.lastException);
        }
        recordInfo = root.recordInfo;
      }
    } catch (IOException e) {
      logError(e);
      createTempFile();
      recordInfo = null;
    } catch (ClassNotFoundException e) {
      if (e.getMessage().contains("robocode.recording.BattleRecordInfo")) {
        Logger.logError(
            "Sorry, backward compatibility with record from version 1.6 is not provided.");
      } else {
        logError(e);
      }
      createTempFile();
      recordInfo = null;
    } finally {
      FileUtil.cleanupStream(oos);
      FileUtil.cleanupStream(bos);
      FileUtil.cleanupStream(fos);
      FileUtil.cleanupStream(ois);
      FileUtil.cleanupStream(zis);
      FileUtil.cleanupStream(bis);
      FileUtil.cleanupStream(fis);
    }
  }
  public void loadSetup(String[] args) {

    final String nosecMessage =
        "Robocode is running without a security manager.\n"
            + "Robots have full access to your system.\n"
            + "You should only run robots which you trust!";
    final String exMessage =
        "Robocode is running in experimental mode.\n"
            + "Robots have access to their IRobotPeer interfaces.\n"
            + "You should only run robots which you trust!";

    if (RobocodeProperties.isSecurityOff()) {
      Logger.logWarning(nosecMessage);
    }
    if (System.getProperty("EXPERIMENTAL", "false").equals("true")) {
      Logger.logWarning(exMessage);
    }

    setup.tps = properties.getOptionsBattleDesiredTPS();

    // Disable canonical file path cache under Windows as it causes trouble when returning
    // paths with differently-capitalized file names.
    if (System.getProperty("os.name").toLowerCase().startsWith("windows ")) {
      System.setProperty("sun.io.useCanonCaches", "false");
    }

    // Initialize the system property so the AWT does not use headless mode meaning that the
    // GUI (Awt and Swing) is enabled per default when running starting Robocode.
    // It might be set to true later, if the -nodisplay option is set (in the setEnableGUI method).
    // Read more about headless mode here:
    // http://java.sun.com/developer/technicalArticles/J2SE/Desktop/headless/
    System.setProperty("java.awt.headless", "false");

    for (int i = 0; i < args.length; i++) {
      String currentArg = args[i];
      if (currentArg.equalsIgnoreCase("-cwd") && (i < args.length + 1)) {
        changeDirectory(args[i + 1]);
        i++;
      } else if (currentArg.equalsIgnoreCase("-battle") && (i < args.length + 1)) {
        setup.battleFilename = args[i + 1];
        i++;
      } else if (currentArg.equalsIgnoreCase("-record") && (i < args.length + 1)) {
        setup.recordFilename = args[i + 1];
        i++;
      } else if (currentArg.equalsIgnoreCase("-recordXML") && (i < args.length + 1)) {
        setup.recordXmlFilename = args[i + 1];
        i++;
      } else if (currentArg.equalsIgnoreCase("-replay") && (i < args.length + 1)) {
        setup.replayFilename = args[i + 1];
        i++;
      } else if (currentArg.equalsIgnoreCase("-results") && (i < args.length + 1)) {
        setup.resultsFilename = args[i + 1];
        i++;
      } else if (currentArg.equalsIgnoreCase("-tps") && (i < args.length + 1)) {
        setup.tps = Integer.parseInt(args[i + 1]);
        if (setup.tps < 1) {
          Logger.logError("tps must be > 0");
          System.exit(8);
        }
        i++;
      } else if (currentArg.equalsIgnoreCase("-minimize")) {
        setup.minimize = true;
      } else if (currentArg.equalsIgnoreCase("-nodisplay")) {
        if (windowManager != null) {
          windowManager.setEnableGUI(false);
        }
        if (soundManager != null) {
          soundManager.setEnableSound(false);
        }
        setup.tps = 10000; // set TPS to maximum
      } else if (currentArg.equalsIgnoreCase("-nosound")) {
        if (soundManager != null) {
          soundManager.setEnableSound(false);
        }
      } else if (currentArg.equals("-?") || currentArg.equalsIgnoreCase("-help")) {
        printUsage();
        System.exit(0);
      } else {
        Logger.logError("Not understood: " + currentArg);
        printUsage();
        System.exit(8);
      }
    }
    File robotsDir = FileUtil.getRobotsDir();

    if (robotsDir == null) {
      System.err.println("No valid robot directory is specified");
      System.exit(8);
    } else if (!(robotsDir.exists() && robotsDir.isDirectory())) {
      System.err.println('\'' + robotsDir.getAbsolutePath() + "' is not a valid robot directory");
      System.exit(8);
    }

    // The Default Toolkit must be set as soon as we know if we are going to use headless mode or
    // not.
    // That is if the toolkit must be headless or not (GUI on/off). If we are running in headless
    // mode
    // from this point, a HeadlessException will be thrown if we access a AWT/Swing component.
    // Read more about headless mode here:
    // http://java.sun.com/developer/technicalArticles/J2SE/Desktop/headless/
    Toolkit.getDefaultToolkit();
  }
  public void run() {
    Thread.setDefaultUncaughtExceptionHandler(
        new Thread.UncaughtExceptionHandler() {
          @Override
          public void uncaughtException(Thread thread, Throwable t) {
            t.printStackTrace();
          }
        });

    try {
      hostManager.initSecurity();

      // Set the Look and Feel (LAF)
      if (windowManager != null && windowManager.isGUIEnabled()) {
        windowManager.init();
      }
      properties.setOptionsBattleDesiredTPS(setup.tps);

      battleManager.addListener(battleObserver);

      if (windowManager != null && windowManager.isGUIEnabled()) {
        if (!setup.minimize && setup.battleFilename == null && soundManager != null) {
          soundManager.playThemeMusic();
          windowManager.showSplashScreen();
        }
        windowManager.showRobocodeFrame(true, setup.minimize);
        windowManager.showBarCodeScanDialog(true);

        // Play the intro battle if a battle file is not specified and this is the first time
        // Robocode is being run

        if (setup.battleFilename == null && versionManager.isLastRunVersionChanged()) {
          properties.saveProperties();
          windowManager.runIntroBattle();
        }
      }

      final boolean enableCLIRecording =
          (setup.recordFilename != null || setup.recordXmlFilename != null);

      // Note: At this point the GUI should be opened (if enabled) before starting the battle from a
      // battle file
      if (setup.battleFilename != null) {
        if (setup.replayFilename != null) {
          System.err.println(
              "You cannot run both a battle and replay a battle record in the same time.");
          System.exit(8);
        }

        setup.exitOnComplete = true;

        battleManager.setBattleFilename(setup.battleFilename);
        if (new File(battleManager.getBattleFilename()).exists()) {
          battleManager.startNewBattle(
              battleManager.loadBattleProperties(), false, enableCLIRecording);
        } else {
          System.err.println(
              "The specified battle file '" + setup.battleFilename + "' was not found");
          System.exit(8);
        }
      } else if (setup.replayFilename != null) {
        setup.exitOnComplete = true;
        if (setup.replayFilename.toLowerCase().endsWith("xml.zip")) {
          recordManager.loadRecord(setup.replayFilename, BattleRecordFormat.XML_ZIP);
        } else {
          recordManager.loadRecord(setup.replayFilename, BattleRecordFormat.BINARY_ZIP);
        }

        if (new File(setup.replayFilename).exists()) {
          battleManager.replay();
        } else {
          System.err.println(
              "The specified battle record file '" + setup.replayFilename + "' was not found");
          System.exit(8);
        }
      }
    } catch (Throwable e) {
      Logger.logError(e);
    }
  }
示例#7
0
  public void compile(String directory, String fileName) {
    fileName = FileUtil.quoteFileName(fileName);

    ConsoleDialog console;

    if (editor != null) {
      console = new ConsoleDialog(editor, "Compiling", false);
    } else {
      console = new ConsoleDialog();
    }
    console.setSize(500, 400);
    console.setText("Compiling...\n");
    WindowUtil.centerShow(editor, console);

    try {
      StringBuffer command =
          new StringBuffer(compilerBinary)
              .append(' ')
              .append(compilerOptions)
              .append(' ')
              .append(compilerClassPath)
              .append(' ')
              .append(fileName);

      Logger.logMessage("Compile command: " + command);

      ProcessBuilder pb = new ProcessBuilder(command.toString().split(" "));

      pb.redirectErrorStream(true);
      pb.directory(FileUtil.getCwd());
      Process p = pb.start();

      // The waitFor() must done after reading the input and error stream of the process
      console.processStream(p.getInputStream());
      p.waitFor();

      if (p.exitValue() == 0) {
        console.append("Compiled successfully.\n");
        console.setTitle("Compiled successfully.");
      } else {
        console.append("Compile Failed (" + p.exitValue() + ")\n");
        console.setTitle("Compile failed.");
      }
    } catch (IOException e) {
      console.append("Unable to compile!\n");
      console.append("Exception was: " + e.toString() + "\n");
      console.append("Does " + compilerBinary + " exist?\n");
      console.setTitle("Exception while compiling");
    } catch (InterruptedException e) {
      // Immediately reasserts the exception by interrupting the caller thread itself
      Thread.currentThread().interrupt();

      console.append("Compile interrupted.\n");
      console.setTitle("Compile interrupted.");
    }

    int codesize = -1;

    try {
      File fileDir = new File(directory);

      // Call the Codesize utility using reflection
      Object item =
          Class.forName("codesize.Codesize")
              .getMethod("processDirectory", new Class[] {File.class})
              .invoke(null, fileDir);

      codesize =
          (Integer)
              item.getClass()
                  .getMethod("getCodeSize", (Class[]) null)
                  .invoke(item, (Object[]) null);
    } catch (Exception ignore) {
    }
    if (codesize >= 0) {
      String weightClass = null;

      if (codesize >= 1500) {
        weightClass = "MegaBot  (codesize >= 1500 bytes)";
      } else if (codesize > 750) {
        weightClass = "MiniBot  (codesize < 1500 bytes)";
      } else if (codesize > 250) {
        weightClass = "MicroBot (codesize < 750 bytes)";
      } else {
        weightClass = "NanoBot  (codesize < 250 bytes)";
      }
      StringBuilder sb = new StringBuilder();

      sb.append("\n\n---- Codesize ----\n");
      sb.append("Codesize: ").append(codesize).append(" bytes\n");
      sb.append("Robot weight class: ").append(weightClass).append('\n');

      console.append(sb.toString());
    }
  }