Java Config類代碼示例

import battlecode.server.Config; //導入依賴的package包/類
public static boolean run(Config options) {
    if (options.get("bc.client.match") != null && !options.get("bc.client" +
            ".match").trim().equals("")) {
        ClientProxy theProxy;
        try {
            theProxy = new StreamClientProxy(options.get("bc.client" +
                    ".match"));
        } catch (IOException e) {
            e.printStackTrace();
            return false;
        }
        Main.showViewer(createFrame(), new MatchViewer(theProxy, true));
        return true;
    }
    if (options.get("bc.server.mode").equalsIgnoreCase("LOCAL")) {
        runLocal(options);
        return true;
    }
    return battlecode.server.Main.run(options);
}
 

import battlecode.server.Config; //導入依賴的package包/類
/**
 * Checks a set of maps for legality. It will search in bc.game.map-path
 * for the maps, and use the maps whose names are passed in as runtime
 * arguments.
 *
 * @param args names of maps to use.
 */
public static void main(String[] args) {
    System.out.println("Checking maps for tournament legality...");
    File mapPath = new File(Config.getGlobalConfig().get("bc.game.map-path"));
    for (String map : args) {
        try {
            if (!loadMap(map, mapPath).isTournamentLegal()) {
                System.err.println("Illegal map: " + map);
            }
        } catch (Exception e) {
            System.err.println("Couldn't load map: "+map);
            e.printStackTrace();
        }
    }
}
 

import battlecode.server.Config; //導入依賴的package包/類
/**
 * Create a new System.out for this robot and round.
 * @return a stream to use for System.out in the sandboxed player
 */
private PrintStream getOut() {
    //TODO move this logic?

    Config options = Config.getGlobalConfig();

    if (robotController.getTeam() == Team.A
            && options.getBoolean("bc.engine.silence-a")
            || robotController.getTeam() == Team.B
            && options.getBoolean("bc.engine.silence-b")) {
        if (!(cachedOut instanceof SilencedPrintStream)) {
            cachedOut = SilencedPrintStream.theInstance();
        }
        // Modifying Systems specific to this robot.
    } else {
        if (!(cachedOut instanceof RoboPrintStream)) {
            cachedOut = new RoboPrintStream();
        }

        ((RoboPrintStream) cachedOut).updateHeader(
                    robotController.getTeam(),
                    robotController.getType(),
                    robotController.getID(),
                    robotController.getRoundNum()
        );

    }

    return cachedOut;
}
 

import battlecode.server.Config; //導入依賴的package包/類
@Test
public void testBcTesting() throws Exception {
    Config.getGlobalConfig().set("bc.testing.should.terminate", "true");

    SandboxedRobotPlayer player = new SandboxedRobotPlayer("testplayersystem", rc, 0, cache);
    player.setBytecodeLimit(200);

    player.step();
    assertTrue(player.getTerminated());
}
 

import battlecode.server.Config; //導入依賴的package包/類
@Test
public void testDebugMethodsEnabled() throws Exception {
    Config.getGlobalConfig().set("bc.engine.debug-methods", "true");

    SandboxedRobotPlayer player = new SandboxedRobotPlayer("testplayerdebug", rc, 0, cache);
    player.setBytecodeLimit(100);

    player.step();
    assertTrue(player.getTerminated());
}
 

import battlecode.server.Config; //導入依賴的package包/類
@Test
public void testDebugMethodsDisabled() throws Exception {
    Config.getGlobalConfig().set("bc.engine.debug-methods", "false");

    SandboxedRobotPlayer player = new SandboxedRobotPlayer("testplayernodebug", rc, 0, cache);
    player.setBytecodeLimit(200);

    player.step();
    assertTrue(player.getTerminated());
}
 

import battlecode.server.Config; //導入依賴的package包/類
public StreamClientProxy(InputStream stream) throws IOException {
    debug = false;
    if (Config.getGlobalConfig().getBoolean("bc.server.output-xml")) {
        serializer = new XStreamSerializerFactory().createSerializer
                (null, stream, ServerEvent.class);
    } else {
        serializer = new JavaSerializerFactory().createSerializer(null,
                stream, ServerEvent.class);
    }
}
 

import battlecode.server.Config; //導入依賴的package包/類
public static void main(String[] args) {
    final Config options = battlecode.server.Main.setupConfig(args);
    if (!run(options)) {
        System.err.println("invalid bc.server.mode");
        System.exit(64);
    }
}
 

import battlecode.server.Config; //導入依賴的package包/類
/**
 * Fills the dropdown match input boxes with available team and map
 * choices. Either does so locally, if local is selected, or uses an RPC
 * to determine the choices available on the remote host.
 */
private void populateParameters() {
    String[] matchInputs = finder.findMatchInputsLocally();

    if (matchInputs != null) {
        Arrays.sort(matchInputs);

        // Clear dropdowns.
        for (Map.Entry<Parameter, JComboBox> entries : parameters
                .entrySet())
            entries.getValue().removeAllItems();

        Set<String> items = new HashSet<>();

        // Add items.
        for (String s : matchInputs) {
            if (items.contains(s))
                continue;
            items.add(s);
            parameters.get(Parameter.TEAM_A).addItem(s);
            parameters.get(Parameter.TEAM_B).addItem(s);
        }

        items.clear();

        for (String map : GameMapIO.getAvailableMaps(Config.getGlobalConfig().get("bc.game.map-path"))) {
            parameters.get(Parameter.MAP).addItem(map);
        }
    }
}
 

import battlecode.server.Config; //導入依賴的package包/類
public void loadPrefs() {
    if (!loadedPrefsAlready) {
        for (char ch : Config.getGlobalConfig().get("bc.client" +
                ".renderprefs2d").toCharArray()) {
            handleAction(ch);
        }
        loadedPrefsAlready = true;
    }
}
 

import battlecode.server.Config; //導入依賴的package包/類
protected static void checkSettings() {
    if (!checkedSettings) {
        checkedSettings = true;
        Config config = Config.getGlobalConfig();
        lazy = config.getBoolean("bc.engine.lazy-instrumenter");
        fastHash = config.getBoolean("bc.engine.fast-hash");
    }
}
 

import battlecode.server.Config; //導入依賴的package包/類
private static void init() {
    robotsToKill.clear();
    Config options = Config.getGlobalConfig();
    silenced[0] = options.getBoolean("bc.engine.silence-a");
    silenced[1] = options.getBoolean("bc.engine.silence-b");
    DEBUG_BYTECODES = options.getInt("bc.engine.debug-max-bytecodes");
}
 

import battlecode.server.Config; //導入依賴的package包/類
/**
 * Creates a controller that operates over a socket.
 *
 * @return a Controller instance for handling data from the socket source
 */
public static Controller createTCPController(InputStream input, Config options) throws IOException {
    if (Boolean.parseBoolean(options.get("bc.server.output-xml")))
        return new TCPController(XStreamProxy.getXStream().createObjectInputStream(input));
    else
        return new TCPController(new ObjectInputStream(input));
}
 

import battlecode.server.Config; //導入依賴的package包/類
/**
 * Creates a headless controller using config/command-line properties.
 *
 * @param options the properties to use for getting the map and teams.
 */
HeadlessController(Config options) {

    configInfo = new MatchInfo(
            options.get("bc.game.team-a"),
            options.get("bc.game.team-b"),
            options.get("bc.game.maps").split(",")
    );
}
 

import battlecode.server.Config; //導入依賴的package包/類
public static Proxy createProxy(final OutputStream stream)
        throws IOException {
    if (Boolean.parseBoolean(Config.getGlobalConfig().get("bc.server.output-xml")))
        return new XStreamProxy(stream);
    else
        return new Proxy() {
            protected OutputStream getOutputStream() throws IOException {
                return stream;
            }
        };
}