public Color getColor() {
return color;
}
-}
\ No newline at end of file
+}
import java.util.concurrent.ConcurrentHashMap;
public class BoundingBoxCache {
-
- private Map<BoundingBox, Set<BoundingBox>> cache = new ConcurrentHashMap<BoundingBox, Set<BoundingBox>>();
+ private Map<BoundingBox, Set<BoundingBox>> cache = new ConcurrentHashMap<>();
public Map<BoundingBox, Set<BoundingBox>> getBoundingBoxes() {
return cache;
}
public void addBoundingBox(BoundingBox key) {
- Set<BoundingBox> boundingBoxes = new HashSet<BoundingBox>();
+ Set<BoundingBox> boundingBoxes = new HashSet<>();
boundingBoxes.add(key);
addBoundingBoxes(key, boundingBoxes);
}
cache.remove(key);
}
}
-}
\ No newline at end of file
+}
import java.io.File;
public class BoundingBoxOutlineReloaded {
-
public static ClientProxy proxy;
public static void init() {
proxy.playerDisconnectedFromServer();
}
}
-
-
return new BoundingBoxSlimeChunk(minBlockPos, maxBlockPos, color);
}
}
-
public static BoundingBoxStructure from(BlockPos minBlockPos, BlockPos maxBlockPos, Color color) {
return new BoundingBoxStructure(minBlockPos, maxBlockPos, color);
}
-}
\ No newline at end of file
+}
return new BoundingBoxVillage(center, radius, color, spawnsIronGolems, doors, minBlockPos, maxBlockPos);
}
- private void calculateCenterOffsets(Set<BlockPos> doors)
- {
+ private void calculateCenterOffsets(Set<BlockPos> doors) {
boolean processedFirstDoor = false;
int minX = 0;
int maxX = 0;
processedFirstDoor = true;
}
- centerOffsetX = Math.abs(maxX-minX) % 2 == 0 ? 0.5 : (minX < 0 ? 0 : 1);
- centerOffsetZ = Math.abs(maxZ-minZ) % 2 == 0 ? 0.5 : (minZ < 0 ? 0 : 1);
+ centerOffsetX = Math.abs(maxX - minX) % 2 == 0 ? 0.5 : (minX < 0 ? 0 : 1);
+ centerOffsetZ = Math.abs(maxZ - minZ) % 2 == 0 ? 0.5 : (minZ < 0 ? 0 : 1);
}
@Override
}
@Override
- public int hashCode()
- { final int prime = 31;
+ public int hashCode() {
+ final int prime = 31;
int result = super.hashCode();
- for(BlockPos door : doors) {
+ for (BlockPos door : doors) {
result = prime * result + door.hashCode();
}
return result;
public Set<BlockPos> getDoors() {
return doors;
}
-}
\ No newline at end of file
+}
import java.awt.*;
public class BoundingBoxWorldSpawn extends BoundingBox {
-
protected BoundingBoxWorldSpawn(BlockPos minBlockPos, BlockPos maxBlockPos, Color color) {
super(minBlockPos, maxBlockPos, color);
}
import java.util.Set;
public class ClientProxy extends CommonProxy {
-
private double activeY;
private boolean active;
private boolean outerBoxOnly;
active = !active;
if (active)
activeY = playerY;
- } else
- if(outerBoxOnlyHotKey.isPressed()){
+ } else if (outerBoxOnlyHotKey.isPressed()) {
outerBoxOnly = !outerBoxOnly;
}
}
localStructuresFolder = new File(configManager.configDir, path);
Logger.info("Looking for local structures (folder=%s)", localStructuresFolder.getAbsolutePath());
}
- if (!localStructuresFolder.exists()) {
+ if (!localStructuresFolder.exists()) {
Logger.info("No local structures folders found");
return;
}
if (configManager.drawStrongholds.getBoolean()) {
loadStructureNbtFile(localStructuresFolder, cache, "Stronghold.dat", StructureType.Stronghold.getColor(), "*");
}
- if (configManager.drawMansions.getBoolean()){
+ if (configManager.drawMansions.getBoolean()) {
loadStructureNbtFile(localStructuresFolder, cache, "Mansion.dat", StructureType.Mansion.getColor(), "*");
}
if (configManager.drawMineShafts.getBoolean()) {
}
private Set<BlockPos> getDoors(NBTTagCompound village) {
- Set<BlockPos> doors = new HashSet<BlockPos>();
+ Set<BlockPos> doors = new HashSet<>();
for (NBTTagCompound door : getChildCompoundTags(village, "Doors")) {
doors.add(new BlockPos(door.getInteger("X"), door.getInteger("Y"), door.getInteger("Z")));
}
for (Object key : features.getKeySet()) {
NBTTagCompound feature = features.getCompoundTag((String) key);
BoundingBox structure = BoundingBoxStructure.from(feature.getIntArray("BB"), color);
- Set<BoundingBox> boundingBoxes = new HashSet<BoundingBox>();
+ Set<BoundingBox> boundingBoxes = new HashSet<>();
NBTTagCompound[] children = getChildCompoundTags(feature, "Children");
for (NBTTagCompound child : children) {
if (id.equals(child.getString("id")) || id.equals("*"))
}
private void renderBoundingBoxes(Map<BoundingBox, Set<BoundingBox>> map, Set<BoundingBox> clientBoundingBoxes) {
- if(map == null && clientBoundingBoxes == null)
+ if (map == null && clientBoundingBoxes == null)
return;
GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
GL11.glClear(GL11.GL_DEPTH_BUFFER_BIT);
}
- if(map != null)
- for (BoundingBox bb : map.keySet()) {
- if (outerBoxOnly) {
- renderBoundingBoxSet(map.get(bb));
- } else {
- renderBoundingBoxByType(bb);
+ if (map != null)
+ for (BoundingBox bb : map.keySet()) {
+ if (outerBoxOnly) {
+ renderBoundingBoxSet(map.get(bb));
+ } else {
+ renderBoundingBoxByType(bb);
+ }
}
- }
- if(clientBoundingBoxes != null)
+ if (clientBoundingBoxes != null)
renderBoundingBoxSet(clientBoundingBoxes);
GL11.glPolygonMode(GL11.GL_FRONT_AND_BACK, GL11.GL_FILL);
}
private void renderBoundingBoxSet(Set<BoundingBox> bbList) {
- if(bbList != null)
- for (BoundingBox bb : bbList) {
- renderBoundingBoxByType(bb);
- }
+ if (bbList != null)
+ for (BoundingBox bb : bbList) {
+ renderBoundingBoxByType(bb);
+ }
}
private void renderBoundingBoxByType(BoundingBox bb) {
villageBB.getSpawnsIronGolems()) {
renderIronGolemSpawnArea(villageBB);
}
- if(configManager.drawVillageDoors.getBoolean())
+ if (configManager.drawVillageDoors.getBoolean())
renderVillageDoors(villageBB);
} else if (bb instanceof BoundingBoxSlimeChunk) {
renderSlimeChunk((BoundingBoxSlimeChunk) bb);
}
private double getMaxY(double configMaxY) {
-
if (configMaxY == -1) {
return activeY;
} else if ((configMaxY == 0) || (playerY < configMaxY)) {
.endVertex();
if (bb.minY != bb.maxY) {
-
worldRenderer.pos(bb.minX, bb.maxY, bb.minZ)
.color(colorR, colorG, colorB, alphaChannel)
.endVertex();
private void renderBoundingBoxVillageAsSphere(BoundingBoxVillage bb) {
OffsetPoint center = new OffsetPoint(bb.getCenter())
- .add(bb.getCenterOffsetX(), 0.0, bb.getCenterOffsetZ());;
+ .add(bb.getCenterOffsetX(), 0.0, bb.getCenterOffsetZ());
+ ;
int radius = bb.getRadius();
Color color = bb.getColor();
renderSphere(center, radius, color);
}
private Set<OffsetPoint> buildPoints(OffsetPoint center, double radius) {
- Set<OffsetPoint> points = new HashSet<OffsetPoint>(1200);
+ Set<OffsetPoint> points = new HashSet<>(1200);
double tau = 6.283185307179586D;
double pi = tau / 2D;
return null;
}
- Set<BoundingBox> boundingBoxes = new HashSet<BoundingBox>();
+ Set<BoundingBox> boundingBoxes = new HashSet<>();
if (configManager.drawWorldSpawn.getBoolean()) {
boundingBoxes.add(getWorldSpawnBoundingBox(worldData.getSpawnX(), worldData.getSpawnZ()));
boundingBoxes.add(getSpawnChunksBoundingBox(worldData.getSpawnX(), worldData.getSpawnZ()));
int renderDistanceChunks = minecraft.gameSettings.renderDistanceChunks;
int playerChunkX = MathHelper.floor(minecraft.player.posX / 16.0D);
int playerChunkZ = MathHelper.floor(minecraft.player.posZ / 16.0D);
- Set<BoundingBoxSlimeChunk> slimeChunks = new HashSet<BoundingBoxSlimeChunk>();
- for (int chunkX = playerChunkX-renderDistanceChunks; chunkX <= playerChunkX+renderDistanceChunks; ++chunkX) {
+ Set<BoundingBoxSlimeChunk> slimeChunks = new HashSet<>();
+ for (int chunkX = playerChunkX - renderDistanceChunks; chunkX <= playerChunkX + renderDistanceChunks; ++chunkX) {
for (int chunkZ = playerChunkZ - renderDistanceChunks; chunkZ <= playerChunkZ + renderDistanceChunks; ++chunkZ) {
if (isSlimeChunk(chunkX, chunkZ)) {
ChunkPos chunk = new ChunkPos(chunkX, chunkZ);
import net.minecraft.world.DimensionType;
import net.minecraft.world.World;
import net.minecraft.world.chunk.Chunk;
-import net.minecraft.world.gen.IChunkGenerator;
import net.minecraft.world.chunk.IChunkProvider;
import net.minecraft.world.gen.ChunkProviderServer;
+import net.minecraft.world.gen.IChunkGenerator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
public class CommonProxy {
-
- public Map<DimensionType, BoundingBoxCache> boundingBoxCacheMap = new ConcurrentHashMap<DimensionType, BoundingBoxCache>();
+ public Map<DimensionType, BoundingBoxCache> boundingBoxCacheMap = new ConcurrentHashMap<>();
public ConfigManager configManager;
protected WorldData worldData;
property.set(property.getInt(defaultValue));
return property;
}
-}
\ No newline at end of file
+}
import java.util.List;
public class DimensionProcessor extends BoundingBoxCache {
-
private ConfigManager configManager;
private World world;
private IEventHandler eventHandler;
this.world = world;
this.dimensionType = dimensionType;
this.chunkGenerator = chunkGenerator;
- villageCache = new HashMap<Integer, BoundingBoxVillage>();
- slimeChunkCache = new HashSet<BoundingBox>();
- worldSpawnCache = new HashSet<BoundingBox>();
+ villageCache = new HashMap<>();
+ slimeChunkCache = new HashSet<>();
+ worldSpawnCache = new HashSet<>();
}
private DimensionType dimensionType;
}
private Map<StructureType, Collection<StructureStart>> getStructures() {
-
- Map<StructureType, Collection<StructureStart>> structureMap = new HashMap<StructureType, Collection<StructureStart>>();
+ Map<StructureType, Collection<StructureStart>> structureMap = new HashMap<>();
if (chunkGenerator instanceof ChunkGeneratorOverworld) {
if (configManager.drawDesertTemples.getBoolean()) {
structureMap.put(StructureType.DesertTemple, getStructuresWithComponent(getStructures(chunkGenerator, MapGenScatteredFeature.class), ComponentScatteredFeaturePieces.DesertPyramid.class));
structureMap.put(StructureType.MineShaft, getStructures(chunkGenerator, MapGenMineshaft.class));
}
} else if (chunkGenerator instanceof ChunkGeneratorHell) {
-
if (configManager.drawNetherFortresses.getBoolean()) {
structureMap.put(StructureType.NetherFortress, getStructures(chunkGenerator, MapGenNetherBridge.class));
}
- } else if(chunkGenerator instanceof ChunkGeneratorEnd) {
+ } else if (chunkGenerator instanceof ChunkGeneratorEnd) {
if (configManager.drawEndCities.getBoolean()) {
structureMap.put(StructureType.EndCity, getStructures(chunkGenerator, MapGenEndCity.class));
}
}
private Collection<StructureStart> getStructuresWithComponent(Collection<StructureStart> structures, Class structureComponent) {
- Collection<StructureStart> validStructures = new HashSet<StructureStart>();
+ Collection<StructureStart> validStructures = new HashSet<>();
for (StructureStart structure : structures) {
if (structure.getComponents().get(0).getClass().equals(structureComponent)) {
validStructures.add(structure);
if (structureStart.getBoundingBox() != null) {
BoundingBox boundingBox = BoundingBoxStructure.from(structureStart.getBoundingBox(), color);
if (!isCached(boundingBox)) {
- Set<BoundingBox> structureBoundingBoxes = new HashSet<BoundingBox>();
- Iterator structureComponents = structureStart.getComponents().iterator();
- while (structureComponents.hasNext()) {
- StructureComponent structureComponent = (StructureComponent) structureComponents.next();
+ Set<BoundingBox> structureBoundingBoxes = new HashSet<>();
+ for (StructureComponent structureComponent : structureStart.getComponents()) {
structureBoundingBoxes.add(BoundingBoxStructure.from(structureComponent.getBoundingBox(), color));
}
addBoundingBoxes(boundingBox, structureBoundingBoxes);
}
if (configManager.drawVillages.getBoolean() &&
- (world.getVillageCollection() != null)) {
-
- Map<Integer, BoundingBoxVillage> villageBoundingBoxes = new HashMap<Integer, BoundingBoxVillage>();
+ world.getVillageCollection() != null) {
+ Map<Integer, BoundingBoxVillage> villageBoundingBoxes = new HashMap<>();
List<Village> villages = world.getVillageCollection().getVillageList();
for (Village village : villages) {
int villageId = village.hashCode();
}
private Set<BlockPos> getDoorsFromVillage(Village village) {
- Set<BlockPos> doors = new HashSet<BlockPos>();
+ Set<BlockPos> doors = new HashSet<>();
for (Object doorInfo : village.getVillageDoorInfoList()) {
VillageDoorInfo villageDoorInfo = (VillageDoorInfo) doorInfo;
doors.add(villageDoorInfo.getDoorBlockPos());
private void processDelta(Map<Integer, BoundingBoxVillage> oldVillages, Map<Integer, BoundingBoxVillage> newVillages) {
for (BoundingBox village : oldVillages.values()) {
removeBoundingBox(village);
- if(eventHandler!=null) {
+ if (eventHandler != null) {
eventHandler.boundingBoxRemoved(this.dimensionType, village);
}
}
addBoundingBox(village);
}
}
-}
\ No newline at end of file
+}
public class Logger {
private static final org.apache.logging.log4j.Logger logger = LogManager.getLogger();
-
public static void info(String s, Object... objects) {
- if (objects.length == 0)
+ if (objects.length == 0) {
logger.info(s);
- else
+ } else {
logger.info(String.format(s, objects));
+ }
}
-}
\ No newline at end of file
+}
import java.util.Map;
public class ReflectionHelper {
-
public static <T, R> R getPrivateValue(Class<T> sourceClass, T instance, Class<R> resultClass) {
try {
Field f = getField(sourceClass, resultClass);
return null;
}
- private static Map<Class, Map<Class, Field>> fieldMap = new HashMap<Class, Map<Class, Field>>();
+ private static Map<Class, Map<Class, Field>> fieldMap = new HashMap<>();
protected static <T, R> Field getField(Class<T> sourceClass, Class<R> resultClass) {
Map<Class, Field> map = fieldMap.get(sourceClass);
- if(map == null)
- {
- map = new HashMap<Class, Field>();
+ if (map == null) {
+ map = new HashMap<>();
fieldMap.put(sourceClass, map);
}
Field field = map.get(resultClass);
- if(field == null) {
+ if (field == null) {
field = getFieldUsingReflection(sourceClass, resultClass);
if (field != null) {
field.setAccessible(true);
private static <T, R> Field getFieldUsingReflection(Class<T> sourceClass, Class<R> resultClass) {
Field[] fields = sourceClass.getDeclaredFields();
- for(Field field : fields) {
- if(field.getType().equals(resultClass))
+ for (Field field : fields) {
+ if (field.getType().equals(resultClass))
return field;
}
- for(Field field : fields) {
- if(resultClass.isAssignableFrom(field.getType()))
+ for (Field field : fields) {
+ if (resultClass.isAssignableFrom(field.getType()))
return field;
}
return null;
public final static StructureType EndCity = new StructureType(END_CITY);
public final static StructureType Mansion = new StructureType(MANSION);
-
private final int type;
private StructureType(int type) {
-
this.type = type;
}
case END_CITY:
return Color.MAGENTA;
case MANSION:
- return new Color(139,69,19);
+ return new Color(139, 69, 19);
}
return Color.WHITE;
}
}
}
- Map<String, Map<String, Setting>> settingsGroup = new HashMap<String, Map<String, Setting>>();
+ Map<String, Map<String, Setting>> settingsGroup = new HashMap<>();
public void load() {
try {
}
if (category == null && trimmedLine.endsWith("{")) {
category = trimmedLine.substring(0, trimmedLine.length() - 1).trim();
- settingsGroup.put(category, new HashMap<String, Setting>());
+ settingsGroup.put(category, new HashMap<>());
continue;
}
if (category != null) {
public Setting get(String category, String settingName, Object defaultValue) {
if (!settingsGroup.containsKey(category)) {
- settingsGroup.put(category, new HashMap<String, Setting>());
+ settingsGroup.put(category, new HashMap<>());
}
Map<String, Setting> settings = settingsGroup.get(category);
if (!settings.containsKey(settingName)) {
package com.irtimaled.bbor.config;
public class Setting {
-
private Object value;
public String comment;
public Setting(Object value) {
-
this.value = value;
}
public Object getValue() {
return value;
}
-}
\ No newline at end of file
+}
import net.minecraftforge.fml.common.network.FMLNetworkEvent;
public class ForgeClientProxy extends ForgeCommonProxy {
-
private ClientProxy proxy;
@Override
import java.util.concurrent.ConcurrentHashMap;
public class ForgeCommonProxy implements IEventHandler {
-
- public Map<EntityPlayerMP, DimensionType> playerDimensions = new ConcurrentHashMap<EntityPlayerMP, DimensionType>();
- private Map<EntityPlayerMP, Set<BoundingBox>> playerBoundingBoxesCache = new HashMap<EntityPlayerMP, Set<BoundingBox>>();
- public HashSet<EntityPlayerMP> registeredPlayers = new HashSet<EntityPlayerMP>();
+ public Map<EntityPlayerMP, DimensionType> playerDimensions = new ConcurrentHashMap<>();
+ private Map<EntityPlayerMP, Set<BoundingBox>> playerBoundingBoxesCache = new HashMap<>();
+ public HashSet<EntityPlayerMP> registeredPlayers = new HashSet<>();
protected CommonProxy getProxy() {
if (commonProxy == null)
public void tickEvent(TickEvent event) {
for (EntityPlayerMP player : playerDimensions.keySet()) {
MinecraftServer mc = FMLCommonHandler.instance().getMinecraftServerInstance();
- if(!mc.getPlayerList().getPlayers().contains(player)) {
+ if (!mc.getPlayerList().getPlayers().contains(player)) {
playerDimensions.remove(player);
} else {
DimensionType dimensionType = playerDimensions.get(player);
}
private void sendToPlayer(EntityPlayerMP player, BoundingBoxCache boundingBoxCache) {
- if(boundingBoxCache == null)
+ if (boundingBoxCache == null)
return;
Map<BoundingBox, Set<BoundingBox>> cacheSubset = getBoundingBoxMap(player, boundingBoxCache.getBoundingBoxes());
network.sendTo(AddBoundingBoxMessage.from(dimensionType, key, boundingBoxes), player);
if (!playerBoundingBoxesCache.containsKey(player)) {
- playerBoundingBoxesCache.put(player, new HashSet<BoundingBox>());
+ playerBoundingBoxesCache.put(player, new HashSet<>());
}
playerBoundingBoxesCache.get(player).add(key);
}
}
private Map<BoundingBox, Set<BoundingBox>> getBoundingBoxMap(EntityPlayerMP player, Map<BoundingBox, Set<BoundingBox>> boundingBoxMap) {
- Map<BoundingBox, Set<BoundingBox>> cacheSubset = new HashMap<BoundingBox, Set<BoundingBox>>();
+ Map<BoundingBox, Set<BoundingBox>> cacheSubset = new HashMap<>();
for (BoundingBox key : boundingBoxMap.keySet()) {
if (!playerBoundingBoxesCache.containsKey(player) || !playerBoundingBoxesCache.get(player).contains(key)) {
cacheSubset.put(key, boundingBoxMap.get(key));
import com.irtimaled.bbor.ConfigManager;
import net.minecraftforge.common.MinecraftForge;
-import net.minecraftforge.fml.common.FMLCommonHandler;
import net.minecraftforge.fml.common.Mod;
import net.minecraftforge.fml.common.SidedProxy;
import net.minecraftforge.fml.common.event.FMLInitializationEvent;
@Mod(modid = ForgeMod.MODID, name = ForgeMod.NAME, version = ForgeMod.VERSION, acceptedMinecraftVersions = ForgeMod.MCVERSION, acceptableRemoteVersions = "*")
public class ForgeMod {
-
public static final String MODID = "bbor";
public static final String NAME = "Bounding Box Outline Reloaded";
public static final String VERSION = "1.0.0-beta18";
@Mod.EventHandler
public void load(FMLInitializationEvent evt) {
MinecraftForge.EVENT_BUS.register(proxy);
-
proxy.init(configManager);
}
}
-
-
public void fromBytes(ByteBuf buf) {
dimensionType = DimensionType.getById(ByteBufUtils.readVarInt(buf, 5));
key = BoundingBoxDeserializer.deserialize(buf);
- boundingBoxes = new HashSet<BoundingBox>();
+ boundingBoxes = new HashSet<>();
while (buf.isReadable()) {
BoundingBox boundingBox = BoundingBoxDeserializer.deserialize(buf);
boundingBoxes.add(boundingBox);
ForgeMod.proxy.addBoundingBox(message.getDimensionType(), message.getKey(), message.getBoundingBoxes());
return null;
}
-}
\ No newline at end of file
+}
int radius = ByteBufUtils.readVarInt(buf, 5);
boolean spawnsIronGolems = ByteBufUtils.readVarShort(buf) == 1;
Color color = new Color(ByteBufUtils.readVarInt(buf, 5));
- Set<BlockPos> doors = new HashSet<BlockPos>();
+ Set<BlockPos> doors = new HashSet<>();
while (buf.isReadable()) {
BlockPos door = deserializeBlockPos(buf);
doors.add(door);
int z = ByteBufUtils.readVarInt(buf, 5);
return new BlockPos(x, y, z);
}
-}
\ No newline at end of file
+}
import java.awt.*;
public class BoundingBoxSerializer {
-
public static void serialize(BoundingBox boundingBox, ByteBuf buf) {
if (boundingBox instanceof BoundingBoxVillage) {
serializeVillage((BoundingBoxVillage) boundingBox, buf);
}
}
-
private static void serializeVillage(BoundingBoxVillage boundingBox, ByteBuf buf) {
ByteBufUtils.writeVarShort(buf, 'V');
serializeBlockPos(boundingBox.getCenter(), buf);
ByteBufUtils.writeVarInt(buf, boundingBox.getRadius(), 5);
ByteBufUtils.writeVarShort(buf, boundingBox.getSpawnsIronGolems() ? 1 : 0);
serializeColor(boundingBox.getColor(), buf);
- for(BlockPos door : boundingBox.getDoors())
- {
+ for (BlockPos door : boundingBox.getDoors()) {
serializeBlockPos(door, buf);
}
}
import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
public class InitializeClientMessage implements IMessage {
-
private WorldData worldData;
public static InitializeClientMessage from(WorldData worldData) {
return message;
}
-
@Override
public void fromBytes(ByteBuf buf) {
long seed = buf.readLong();
public class RemoveBoundingBoxMessageHandler implements IMessageHandler<RemoveBoundingBoxMessage, IMessage> {
@Override
public IMessage onMessage(RemoveBoundingBoxMessage message, MessageContext ctx) {
-
ForgeMod.proxy.removeBoundingBox(message.getDimensionType(), message.getKey());
return null;
}
-}
\ No newline at end of file
+}
--- /dev/null
+{
+ "pack": {
+ "description": "bbor resources",
+ "pack_format": 3,
+ "_comment": "A pack_format of 3 should be used starting with Minecraft 1.11. All resources, including language files, should be lowercase (eg: en_us.lang). A pack_format of 2 will load your mod resources with LegacyV2Adapter, which requires language files to have uppercase letters (eg: en_US.lang)."
+ }
+}
projects / BoundingBoxOutlineReloaded.git / commitdiff