Java 类net.minecraftforge.common.config.Property 实例源码

private static void constructFromConfig(String ID,
                             Potion effect,
                             String enableKey,
                             String enableComment,
                             int maxLevelDefault,
                             int defaultDifficultyCost,
                             double defaultWeight,
                             List<DifficultyModifier> returns,
                             Configuration config) {
    Property modifierEnabledProp = config.get(ID,
            enableKey, true, enableComment);
    boolean modifierEnabled = modifierEnabledProp.getBoolean();
    Property MaxLevelProp = config.get(ID,
            "ModifierMaxLevel", maxLevelDefault, "Maximum level of this effect added to the target player when entering the cloud.");
    int maxLevel = MaxLevelProp.getInt();
    Property difficultyCostPerLevelProp = config.get(ID,
            "DifficultyCostPerLevel", defaultDifficultyCost, "Cost of each level of the effect applied to the target player.");
    int diffCostPerLevel = difficultyCostPerLevelProp.getInt();
    Property selectionWeightProp = config.get(ID,
            "ModifierWeight", defaultWeight, "Weight that affects how often this modifier is selected.");
    double selectionWeight = selectionWeightProp.getDouble();
    if (modifierEnabled && maxLevel > 0 && diffCostPerLevel > 0 && selectionWeight > 0) {
        returns.add(new PotionCloudModifier(effect, maxLevel, diffCostPerLevel, selectionWeight, ID));
    }
}

protected <T> T get(String name, String category, String comment, T normal)
{
    try
    {
        Object returned = HarshenUtils.getMethod("get", config.getClass(), String.class, String.class, normal.getClass()).invoke(config, category, name, normal);
        if(normal.getClass().isArray())
            for(Method method : config.getClass().getMethods())
                if(method.getParameterTypes().length == 3 && method.getParameterTypes()[0] == String.class && method.getParameterTypes()[1] == String.class
                && method.getParameterTypes()[2] == normal.getClass() && method.getParameterTypes()[2].isArray())
                    returned = method.invoke(config, category, name, normal);
        if(!(returned instanceof Property)) throw new IllegalArgumentException("Returned Type was not a property. This is practically impossible");
        Property property = (Property) returned;
        property.setComment(comment);
        propertyMap.put(category + "*" + name, property);
        return (T) property.getClass().getMethod("get" + normal.getClass().getSimpleName().replace("Integer", "Int").replace("[]", "List")).invoke(property);
    }
    catch (NullPointerException | SecurityException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
        HarshenCastle.LOGGER.error("Forge Config has no such getter for " + normal.getClass() + ". ErrorClass: " + e.getClass().getSimpleName());
        e.printStackTrace();
    }
    return normal;
}

@Mod.EventHandler
public void preInit(FMLPreInitializationEvent e) {

    Configuration config = new Configuration(new File(e.getModConfigurationDirectory(), "creativezone.cfg"));
    config.load();

    // Check interval (seconds)
    checkInterval = config.getInt("ScanInterval", "config", 1, 1, 60,
            "Sets the interval (in seconds) for scanning player locations");

    // Creative zone radius
    zoneRadius = config.getInt("ZoneRadius", "config", 25, 5, 1000,
            "Sets the radius of the creative zone");

    Property whiteListProp = config.get("config", "Whitelist", new String[0],
            "Gets the list of whitelisted users");
    for (String s : whiteListProp.getStringList()) {
        whitelist.add(s);
    }

    config.save();
}

private static void syncConfig(boolean load) {
    List<String> propOrder = new ArrayList<String>();
    try {
        Property prop = null;
        if(!config.isChild) {
            if(load) {
                config.load();
            }
        }

        biomeIDSpace = getIntegerConfigNode(config, prop, propOrder, Constants.CONFIG_CATEGORY_DIMENSIONS, "biomeIDSpace", "Biome ID for Space.", 100);

        config.setCategoryPropertyOrder(CATEGORY_GENERAL, propOrder);

           if (config.hasChanged())
           {
               config.save();
           }
    }catch (final Exception ex) {
        FMLLog.log(Level.ERROR, ex, "Trappist-1 has a problem loading it's config, this can have negative repercussions.");
    }
}

private static void syncConfig(boolean load) {
    List<String> propOrder = new ArrayList<String>();
    try {
        Property prop = null;
        if(!config.isChild) {
            if(load) {
                config.load();
            }
        }

        dimensionIDTrappistOneB = getIntegerConfigNode(config, prop, propOrder, Constants.CONFIG_CATEGORY_DIMENSIONS, "dimensionIDTrappistOneB", "Dimension ID for Trappist-1B.", -35);
        dimensionIDTrappistOneC = getIntegerConfigNode(config, prop, propOrder, Constants.CONFIG_CATEGORY_DIMENSIONS, "dimensionIDTrappistOneC", "Dimension ID for Trappist-1C.", -36);

        config.setCategoryPropertyOrder(CATEGORY_GENERAL, propOrder);

           if (config.hasChanged())
           {
               config.save();
           }
    }catch (final Exception ex) {
        FMLLog.log(Level.ERROR, ex, "Trappist-1 has a problem loading it's config, this can have negative repercussions.");
    }
}

public static Property.Type fromJavaPrimitiveType(Class<?> javaType)
{
    if (javaType.equals(Byte.TYPE) || javaType.equals(Short.TYPE) || javaType.equals(Integer.TYPE))
    {
        return Property.Type.INTEGER;
    }

    if (javaType.equals(Float.TYPE) || javaType.equals(Double.TYPE) || javaType.equals(Long.TYPE))
    {
        return Property.Type.DOUBLE;
    }

    if (javaType.equals(Boolean.TYPE))
    {
        return Property.Type.BOOLEAN;
    }

    return Property.Type.STRING;
}

public static void setZoomAmount(int zoomAmount) {
    if (zoomAmount > MAX_ZOOM) {
        zoomAmount = MAX_ZOOM;
    } else if (zoomAmount < MIN_ZOOM) {
        zoomAmount = MIN_ZOOM;
    }

    if (Config.zoomAmount != zoomAmount) {
        Config.zoomAmount = zoomAmount;
        if (config != null) {
            String configComment = I18n.format("config.itemzoom.zoom.amount");
            configComment = configComment + " [range: " + MIN_ZOOM + " ~ " + MAX_ZOOM + ", default: " + DEFAULT_ZOOM + "]";
            Property property = config.get(category, "zoom.amount", DEFAULT_ZOOM, configComment, MIN_ZOOM, MAX_ZOOM);
            property.set(Config.zoomAmount);
            if (config.hasChanged()) {
                config.save();
            }
        }
    }
}

/**
 * Refreshes this mod's configuration
 */
public void refresh()
{
    load();

    Property prop;

    prop = get("options", "spinspeed", 1.0D);
    prop.setLanguageKey("globalxp.config.spinspeed");
    spinSpeed = prop.getDouble(1.0D);

    prop = get("options", "bobspeed", 1.0D);
    prop.setLanguageKey("globalxp.config.bobspeed");
    bobSpeed = prop.getDouble(1.0D);

    prop = get("options", "renderNameplate", true);
    prop.setLanguageKey("globalxp.config.renderNameplate");
    renderNameplate = prop.getBoolean(true);

    if(hasChanged())
        save();
}

public static void onConfigApplied()
{
    AuthlibLoginHelper instance = AuthlibLoginHelper.getInstance();
    for (Property property : PROPERTIES.values())
    {
        if (property.hasChanged())
        {
            String address = property.getName();
            AuthlibLoginHelper.Data data = RESULTS.get(property.getString());
            if (data != null)
            {
                instance.saveAccount(address, data);
            }
        }
    }
}

private static List<IConfigElement> getConfigElements()
{
    PROPERTIES.clear();
    ImmutableList.Builder<IConfigElement> builder = ImmutableList.builder();
    Map<String, AuthlibLoginHelper.Data> accounts = AuthlibLoginHelper.getInstance().listAccounts();
    for (Map.Entry<String, AuthlibLoginHelper.Data> entry : accounts.entrySet())
    {
        String name = entry.getKey();
        AuthlibLoginHelper.Data data = entry.getValue();
        boolean skip = data.userid.isEmpty() && !data.accessToken.isPresent();

        String[] choices = skip ? SKIP_CHOICES.toArray(new String[0]) : LOGIN_CHOICES.toArray(new String[0]);
        Property property = new Property(name, choices[0], Property.Type.STRING, choices);
        property.setComment(skip ? SKIP_COMMENT : LOGIN_COMMENT);

        builder.add(new ConfigElement(property));
        PROPERTIES.put(name, property);
    }
    return builder.build();
}

public static void setupBookConfig(Configuration cfg) {
    ConfigCategory category = cfg.getCategory(CATEGORY_BOOKS);
    if (category.isEmpty()) {
        // Initialize with defaults
        addBook(cfg, Items.BOOK.getRegistryName().toString(), "*");
        addBook(cfg, Items.ENCHANTED_BOOK.getRegistryName().toString(), "*");
        addBook(cfg, Items.WRITABLE_BOOK.getRegistryName().toString(), "*");
        addBook(cfg, Items.WRITTEN_BOOK.getRegistryName().toString(), "*");
        addBook(cfg, "rftools:rftools_manual", BookType.BOOK_BLUE.getModel());
        addBook(cfg, "rftoolscontrol:rftoolscontrol_manual", BookType.BOOK_GREEN.getModel());
        addBook(cfg, "rftoolsdim:rftoolsdim_manual", BookType.BOOK_GREEN.getModel());
        addBook(cfg, "deepresonance:dr_manual", BookType.BOOK_RED.getModel());
    } else {
        for (Map.Entry<String, Property> entry : category.entrySet()) {
            validBooks.put(entry.getKey(), entry.getValue().getString());
        }
    }
}

public static boolean getBooleanFor(Configuration config,String heading, String item, boolean value, String comment)
{
    if (config == null)
        return value;
    try
    {
        Property prop = config.get(heading, item, value);
        prop.comment = comment;
        return prop.getBoolean(value);
    }
    catch (Exception e)
    {
        System.out.println("[" + ModDetails.ModName + "] Error while trying to add Integer, config wasn't loaded properly!");
    }
    return value;
}

public static int getIntFor(Configuration config,String heading, String item, int value, String comment)
{
    if (config == null)
        return value;
    try
    {
        Property prop = config.get(heading, item, value);
        prop.comment = comment;
        return prop.getInt(value);
    }
    catch (Exception e)
    {
        System.out.println("[" + ModDetails.ModName + "] Error while trying to add Integer, config wasn't loaded properly!");
    }
    return value;
}

public static double getDoubleFor(Configuration config,String heading, String item, double value, String comment)
{
    if (config == null)
        return value;
    try
    {
        Property prop = config.get(heading, item, value);
        prop.comment = comment;
        return prop.getDouble(value);
    }
    catch (Exception e)
    {
        System.out.println("[" + ModDetails.ModName + "] Error while trying to add Double, config wasn't loaded properly!");
    }
    return value;
}

static void loadConfiguration()
{
    ticketConstraints.clear();
    chunkConstraints.clear();
    for (String mod : config.getCategoryNames())
    {
        if (mod.equals("Forge") || mod.equals("defaults"))
        {
            continue;
        }
        Property modTC = config.get(mod, "maximumTicketCount", 200);
        Property modCPT = config.get(mod, "maximumChunksPerTicket", 25);
        ticketConstraints.put(mod, modTC.getInt(200));
        chunkConstraints.put(mod, modCPT.getInt(25));
    }
    if (config.hasChanged())
    {
        config.save();
    }
}

public static void initConfig(File configFile) { // Gets called from preInit
    try {

        // Ensure that the config file exists
        if (!configFile.exists()) configFile.createNewFile();

        // Create the config object
        config = new Configuration(configFile);

        // Load config
        config.load();

        // Read props from config
        Property debugModeProp = config.get(Configuration.CATEGORY_GENERAL, // What category will it be saved to, can be any string
                "debug_mode", // Property name
                "false", // Default value
                "Enable the debug mode (useful for reporting issues)"); // Comment

        DEBUG_MODE = debugModeProp.getBoolean(); // Get the boolean value, also set the property value to boolean
    } catch (Exception e) {
        // Failed reading/writing, just continue
    } finally {
        // Save props to config IF config changed
        if (config.hasChanged()) config.save();
    }
}

public static void loadFile(File file) {
    FMLLog.info("[Muon] %s", "Loading config from "+file.getName());
    // Sets up a new config
    config = new Configuration(file);
    config.load();

    config.setCategoryComment(CATEGORY_GENERATION, "Options controlling generation of new villages.\nThese only take effect as new chunks are generated.");
    properties.put("enable_new_by_default", config.get(CATEGORY_GENERATION, "enable_new_by_default", false, "Enable features of new versions by default"));
    properties.put("fix_buried_doors", config.get(CATEGORY_GENERATION, "fix_buried_doors", true, "Align village buildings with the path only"));
    properties.put("better_paths", config.get(CATEGORY_GENERATION, "better_paths", true, "Use alternate function for creating village paths"));
    properties.put("smooth_village_terrain", config.get(CATEGORY_GENERATION, "smooth_village_terrain", true, "Smooth terrain within village boundaries"));
    properties.put("fix_scattered_features", config.get(CATEGORY_GENERATION, "fix_scattered_features", true, "Ensure scattered features (e.g. Desert temples and Igloos) are accessible."));
    int village_grove_frequency_default = 0;
    if (getBoolean("enable_new_by_default")) {
        if (!config.hasKey(CATEGORY_GENERATION, "village_grove_frequency")) {
            village_grove_frequency_default = 100;
        }
    }
    Property village_grove_frequency = config.get(CATEGORY_GENERATION, "village_grove_frequency", village_grove_frequency_default, "Add stands of trees to villages.");
    village_grove_frequency.setMinValue(0);
    village_grove_frequency.setMaxValue(100);
    properties.put("village_grove_frequency", village_grove_frequency);

    // write out default config if necessary
    config.save();
}

static void loadConfiguration()
{
    ticketConstraints.clear();
    chunkConstraints.clear();
    for (String mod : config.getCategoryNames())
    {
        if (mod.equals("Forge") || mod.equals("defaults"))
        {
            continue;
        }
        Property modTC = config.get(mod, "maximumTicketCount", 200);
        Property modCPT = config.get(mod, "maximumChunksPerTicket", 25);
        ticketConstraints.put(mod, modTC.getInt(200));
        chunkConstraints.put(mod, modCPT.getInt(25));
    }
    if (config.hasChanged())
    {
        config.save();
    }
}

@EventHandler
public void init(FMLPreInitializationEvent event)
{
    Configuration config = new Configuration(new File(event.getModConfigurationDirectory(), NAME + ".cfg"));
    config.load();

    Property prop = config.get(Configuration.CATEGORY_CLIENT, "verboseDebug", false,
            "If true, verbose debugging will be written to the log.");
    verbose = prop.getBoolean();
    if (verbose) {
        out = System.out;
    }
    prop = config.get(Configuration.CATEGORY_GENERAL, "enableCommand", false,
            "If true, the /xpseed command will be enabled, allowing you to retrieve "
            + "and set players' enchantment seeds directly.");
    enableCommand = prop.getBoolean();

    if (config.hasChanged()) {
        config.save();
    }
    EnchantmentRevealer.out.println("EnchantmentRevealer initialized.");
    MinecraftForge.EVENT_BUS.register(events);
}

public static boolean getBooleanFor(Configuration config,String heading, String item, boolean value, String comment)
{
    if (config == null)
        return value;
    try
    {
        Property prop = config.get(heading, item, value);
        prop.comment = comment;
        return prop.getBoolean(value);
    }
    catch (Exception e)
    {
        System.out.println("[" + TFCPPDetails.ModName + "] Error while trying to add Integer, config wasn't loaded properly!");
    }
    return value;
}

public void setValue(Property inFile) {
    Type oldValue = value();
    set = inFile.wasRead();
    if (set) {
        try {
            value = dataFrom(inFile);
        } catch (NullPointerException e) {
            value = value();
        }
    } else {
        value = value();
    }
    if ((oldValue ==null&&value()!=null)) {
        //ConfigManager.logger.info("updating null to "+value().toString());
        update(value());
    } else {
        if (!oldValue.equals(value())) {
            //ConfigManager.logger.info("updating "+this.key+ " to "+value().toString());
            update(value());
        }
    }
}

private Property.Type parseType(PrimitiveType primitiveType)
{
    Property.Type propType = null;
    switch (primitiveType)
    {
        case BOOL:
            propType = Property.Type.BOOLEAN;
            break;
        case BYTE:
        case SHORT:
        case INT:
        case LONG:
            propType = Property.Type.INTEGER;
            break;
        case FLOAT:
        case DOUBLE:
            propType = Property.Type.DOUBLE;
            break;
    }
    return propType;
}

@Override
public BooleanSupplier parse(JsonContext context, JsonObject json)
{
    JsonPrimitive categoryName = json.getAsJsonPrimitive("category");
    JsonPrimitive keyName = json.getAsJsonPrimitive("key");

    ConfigCategory category = ConfigManager.instance.config.getCategory(categoryName.getAsString());
    Property property = category != null ? category.get(keyName.getAsString()) : null;

    if (property == null)
    {
        Survivalist.logger.error("Property not found! {} / {}", categoryName.getAsString(), keyName.getAsString());
        return () -> false;
    }

    return property::getBoolean;
}

public void setValue(Property inFile) {
    Type oldValue = value();
    set = inFile.wasRead();
    if (set) {
        value = dataFrom(inFile);
    } else {
        value = defaultValue;
    }
    if ((oldValue ==null&&value()!=null)) {
        ConfigManager.logger.info("updating null to "+value().toString());
        update(value());
    } else {
        if (!oldValue.equals(value())) {
            ConfigManager.logger.info("updating "+this.key+ " to "+value().toString());
            update(value());
        }
    }
}

public static double getDoubleFor(Configuration config,String heading, String item, double value, String comment)
{
    if (config == null)
        return value;
    try
    {
        Property prop = config.get(heading, item, value);
        prop.comment = comment;
        return prop.getDouble(value);
    }
    catch (Exception e)
    {
        System.out.println("[" + TFCPPDetails.ModName + "] Error while trying to add Double, config wasn't loaded properly!");
    }
    return value;
}

@Mod.EventHandler
public void preInit(FMLPreInitializationEvent event)
{
    logger = event.getModLog();
    config = new Configuration(event.getSuggestedConfigurationFile());
    Property breakChest = config.get("Balance", "BreakChestOnHarvest", true);
    if (!breakChest.wasRead())
        config.save();
    else
        breakChestOnHarvest = breakChest.getBoolean();

    registerTileEntities();

    NetworkRegistry.INSTANCE.registerGuiHandler(this, guiHandler);

    channel = NetworkRegistry.INSTANCE.newSimpleChannel(CHANNEL);

    int messageNumber = 0;
    channel.registerMessage(UpdatePlayersUsing.Handler.class, UpdatePlayersUsing.class, messageNumber++, Side.CLIENT);
    logger.debug("Final message number: " + messageNumber);

    proxy.preInit();
}

public double getAxeLevelMultiplier(int axeLevel)
{
    if (axeLevelMap.containsKey(axeLevel))
        return axeLevelMap.get(axeLevel);

    double value = 1 + axeLevel;

    if (axeMultipliers != null)
    {
        Property p = axeMultipliers.get("AxeLevel" + axeLevel);
        if (p != null && p.wasRead())
        {
            value = p.getDouble();
        }
    }

    axeLevelMap.put(axeLevel, value);
    return value;
}

public static int getIntFor(Configuration config, String heading, String item, int value, int minValue, int maxValue, String comment) {
    if (config == null)
        return value;
    try {
        Property prop = config.get(heading, item, value);
        prop.comment = comment + " [range: " + minValue + " ~ " + maxValue + ", default: " + value + "]";
        prop.setMinValue(minValue);
        prop.setMaxValue(maxValue);
        if (prop.getInt(value) < minValue || prop.getInt(value) > maxValue) {
            TFCTech.LOG.info("An invalid value has been entered for " + item
                    + " in the config file. Reverting to the default value.");
            prop.set(value);
            return value;
        }
        return prop.getInt(value);
    } catch (Exception e) {
        TFCTech.LOG.error("Error while trying to add Integer, config wasn't loaded properly!");
    }
    return value;
}

public static Property getOption(EMod mod, String name) {
    if (mods.containsKey(mod)) {
        return mods.get(mod).getOption(name);
    } else {
        return null;
    }
}

public static boolean getBoolean(EMod mod, String name, boolean defaultBoolean) {
    Property prop = getOption(mod, name);
    if (prop == null) {
        return defaultBoolean;
    } else {
        return prop.getBoolean(defaultBoolean);
    }
}

@Override
public void read() {
    for(T componant: allComponants)
    {
        if(!testIfLegit(componant))
        {
            continue;
        }
        Property property = config.get(CATEGORY, getComponantPathInConfig(componant), true);
        property.setComment(new TextComponentTranslation("config.isEnabled", getComponantCommentName(componant)).getUnformattedText());
        enabledMap.put(componant, property.getBoolean());
    }
}

private static int[] getTierBasedIntList(Configuration cfg, String name, String category, int[] def, String comment) {
    Property prop = cfg.get(category, name, def, comment);
    int[] ret = prop.getIntList();
    if(ret == null || ret.length < 3) {
        ret = def;
        prop.set(ret);
    }
    return ret;
}

public static int getIntegerConfigNode(Configuration conf, Property prop, List<String> propOrder, String category, String key, String discription, int defaultInt) {
    int out;
    prop = conf.get(category, key, defaultInt);
    prop.comment = discription;
    prop.setLanguageKey("gc.configgui.dimensionIDMars").setRequiresMcRestart(true);
    out = prop.getInt();
    propOrder.add(prop.getName());
    return out;
}

public static int getIntegerConfigNode(Configuration conf, Property prop, List<String> propOrder, String category, String key, String discription, int defaultInt) {
    int out;
    prop = conf.get(category, key, defaultInt);
    prop.comment = discription;
    prop.setLanguageKey("gc.configgui.dimensionIDMars").setRequiresMcRestart(true);
    out = prop.getInt();
    propOrder.add(prop.getName());
    return out;
}

public void serializeRecursive(ConfigCategory categoryCurrent, Object toSerialize)
{
    try
    {
        for (Field f : toSerialize.getClass().getDeclaredFields())
        {
            if (Modifier.isPublic(f.getModifiers()) && !Modifier.isStatic(f.getModifiers()) && !Modifier.isFinal(f.getModifiers()) && !f.isAnnotationPresent(ConfigIgnore.class))
            {
                if (f.getType().isPrimitive() || f.getType().equals(String.class))
                {
                    categoryCurrent.put(f.getName(), new Property(f.getName(), f.get(toSerialize).toString(), fromJavaPrimitiveType(f.getType())));
                }
                else
                {
                    boolean hasAdapter = false;
                    for (ConfigAdapter<Object> a : adapters)
                    {
                        if (a.accepts(f.get(toSerialize)))
                        {
                            a.serialize(f.get(toSerialize), new ConfigCategory(f.getName(), categoryCurrent));
                            hasAdapter = true;
                            break;
                        }
                    }

                    if (!hasAdapter)
                    {
                        serializeRecursive(new ConfigCategory(f.getName(), categoryCurrent), f.get(toSerialize));
                    }
                }
            }
        }
    }
    catch (Exception ex)
    {
        VCLoggers.loggerErrors.log(LogLevel.Error, "Caught an exception trying to serialize a configuration file!", ex);
    }
}

private static void syncConfig() {
    Property prop;

    prop = config.get(Configuration.CATEGORY_GENERAL, "dimensionId", 37);
    prop.setComment("ID for the dimension used by Genesis");
    prop.setRequiresMcRestart(true);
    prop.setLanguageKey("genesis.configgui.dimension_id");
    dimensionId = prop.getInt();

    if (config.hasChanged()) {
        config.save();
    }
}

public static void handleConfig(Configuration config){
    Property current;
    int chunkRange; double maxSpawnTime;
    String[] dimensionArray = {"0"};
    config.load();
    current = config.get(Configuration.CATEGORY_GENERAL, "Logging", false);
    current.setComment("Enable this to receive server messages whenever a villager tries to spawn.  Default false.");
    LOGGING = current.getBoolean();
    current = config.get("SpawnValues", "Chunk check range", 2);
    current.setComment("This is the range in chunks from each player that Emergent Villages checks for valid spawn positions.  Default 2.");
    chunkRange = current.getInt();
    current = config.get("SpawnValues", "Inhabited time for maximum spawn chance", 3600000.0d);
    current.setComment("This is the time in ticks at which the spawn chance for a villager for any given chunk is 100%.  Minecraft increments this timer for each player "
            + "in a chunk once per tick.  Increase this value for a slower spawn rate, and decrease it for a faster spawn rate.  "
            + "Default 3600000.0f.");
    maxSpawnTime = current.getDouble();
    current = config.get(Configuration.CATEGORY_GENERAL, "Max villagers per chunk", 1);
    current.setComment("This is the maximum amount of villagers that Emergent Villages spawns per chunk.  Default 1.");
    SpawnHandler.initConfig(chunkRange, current.getInt(), maxSpawnTime);
    current = config.get(Configuration.CATEGORY_GENERAL , "Dimensions", dimensionArray);
    current.setComment("These are the dimensions that Emergent Villages will spawn villagers in.  Default 0 (Overworld).");
    dimensionArray = current.getStringList();
    current = config.get(Configuration.CATEGORY_GENERAL, "Tick speed", 600);
    current.setComment("This is the amount of time that Emergent Villages waits between checks.  Minecraft ticks 20 times per second.  Higher numbers means that even if "
            + "the regional difficulty is high it will take a while to spawn villagers, but the impact on the server will be low.  Lower numbers means villagers spawn "
            + "faster, up to the limit, but there will be a performance hit.  Default 600.");
    TickHandler.initConfig(current.getInt(), dimensionArray);
    config.save();
}

private static void syncConfig(boolean loadFromConfigFile, boolean readFieldsFromConfig) {
    if (loadFromConfigFile)
        config.load();

    Property propertyMachineCooldownBasic = config.get(CATEGORY_NAME_BLOCKS, "machine_cooldown_basic", 100);
    propertyMachineCooldownBasic.setLanguageKey("gui.config.blocks.machine_cooldown_basic.name");
    propertyMachineCooldownBasic.setComment(I18n.format("gui.config.blocks.machine_cooldown_basic.comment"));
    propertyMachineCooldownBasic.setMinValue(10);
    propertyMachineCooldownBasic.setMaxValue(200);
    Property propertyMachineCooldownAdvanced = config.get(CATEGORY_NAME_BLOCKS, "machine_cooldown_advanced", 50);
    propertyMachineCooldownAdvanced.setLanguageKey("gui.config.blocks.machine_cooldown_advanced.name");
    propertyMachineCooldownAdvanced.setComment(I18n.format("gui.config.blocks.machine_cooldown_advanced.comment"));
    propertyMachineCooldownAdvanced.setMinValue(10);
    propertyMachineCooldownAdvanced.setMaxValue(200);

    List<String> propertyOrderBlocks = new ArrayList<String>();
    propertyOrderBlocks.add(propertyMachineCooldownBasic.getName());
    propertyOrderBlocks.add(propertyMachineCooldownAdvanced.getName());
    config.setCategoryPropertyOrder(CATEGORY_NAME_BLOCKS, propertyOrderBlocks);

    if (readFieldsFromConfig) {
        machineCooldownBasic = propertyMachineCooldownBasic.getInt();
        machineCooldownAdvanced = propertyMachineCooldownAdvanced.getInt();
    }

    propertyMachineCooldownBasic.set(machineCooldownBasic);
    propertyMachineCooldownAdvanced.set(machineCooldownAdvanced);

    if (config.hasChanged())
        config.save();
}

public static void toggleEnabled() {
    toggledEnabled = !toggledEnabled;
    if (config != null) {
        String configComment = I18n.format("config.itemzoom.toggle.enabled");
        Property property = config.get(category, "toggled.enabled", true, configComment);
        property.set(toggledEnabled);
        if (config.hasChanged()) {
            config.save();
        }
    }
}

@SideOnly(Side.CLIENT)
public boolean addToBlacklist(ItemStack stack){
    if(stack.useItemRightClick(Minecraft.getMinecraft().world, new EntityOtherPlayerMP(Minecraft.getMinecraft().world, new GameProfile(null, "fake")), EnumHand.MAIN_HAND).getType()!=EnumActionResult.PASS){
        Property blackList=conf.get("config", "Blacklist items", new String[0]);
        blackList.set(Arrays.copyOf(blackList.getStringList(),blackList.getStringList().length+1));
        blackList.getStringList()[blackList.getStringList().length-1]=stack.getItem().getRegistryName().toString();
        syncConfig();
        return true;
    }
    return false;
}