mirror of
http://git.eaglercraft.rip/eaglercraft/eaglercraft-1.8.git
synced 2025-04-30 02:01:59 -05:00
991 lines
26 KiB
Java
991 lines
26 KiB
Java
package net.optifine;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Collection;
|
|
import java.util.HashMap;
|
|
import java.util.List;
|
|
import java.util.Map;
|
|
import java.util.Properties;
|
|
import net.lax1dude.eaglercraft.v1_8.minecraft.EaglerTextureAtlasSprite;
|
|
import net.minecraft.block.properties.IProperty;
|
|
import net.minecraft.block.state.IBlockState;
|
|
import net.minecraft.client.Minecraft;
|
|
import net.minecraft.client.renderer.texture.TextureMap;
|
|
import net.minecraft.init.Blocks;
|
|
import net.minecraft.util.EnumWorldBlockLayer;
|
|
import net.minecraft.util.ResourceLocation;
|
|
import net.minecraft.world.biome.BiomeGenBase;
|
|
import net.optifine.config.ConnectedParser;
|
|
import net.optifine.config.MatchBlock;
|
|
import net.optifine.config.Matches;
|
|
import net.optifine.config.NbtTagValue;
|
|
import net.optifine.config.RangeInt;
|
|
import net.optifine.config.RangeListInt;
|
|
import net.optifine.util.MathUtils;
|
|
import net.optifine.util.TextureUtils;
|
|
|
|
public class ConnectedProperties {
|
|
public String name = null;
|
|
public String basePath = null;
|
|
public MatchBlock[] matchBlocks = null;
|
|
public int[] metadatas = null;
|
|
public String[] matchTiles = null;
|
|
public int method = 0;
|
|
public String[] tiles = null;
|
|
public int connect = 0;
|
|
public int faces = 63;
|
|
public BiomeGenBase[] biomes = null;
|
|
public RangeListInt heights = null;
|
|
public int renderPass = 0;
|
|
public boolean innerSeams = false;
|
|
public int[] ctmTileIndexes = null;
|
|
public int width = 0;
|
|
public int height = 0;
|
|
public int[] weights = null;
|
|
public int randomLoops = 0;
|
|
public int symmetry = 1;
|
|
public boolean linked = false;
|
|
public NbtTagValue nbtName = null;
|
|
public int[] sumWeights = null;
|
|
public int sumAllWeights = 1;
|
|
public EaglerTextureAtlasSprite[] matchTileIcons = null;
|
|
public EaglerTextureAtlasSprite[] tileIcons = null;
|
|
public MatchBlock[] connectBlocks = null;
|
|
public String[] connectTiles = null;
|
|
public EaglerTextureAtlasSprite[] connectTileIcons = null;
|
|
public int tintIndex = -1;
|
|
public IBlockState tintBlockState = Blocks.air.getDefaultState();
|
|
public EnumWorldBlockLayer layer = null;
|
|
public static final int METHOD_NONE = 0;
|
|
public static final int METHOD_CTM = 1;
|
|
public static final int METHOD_HORIZONTAL = 2;
|
|
public static final int METHOD_TOP = 3;
|
|
public static final int METHOD_RANDOM = 4;
|
|
public static final int METHOD_REPEAT = 5;
|
|
public static final int METHOD_VERTICAL = 6;
|
|
public static final int METHOD_FIXED = 7;
|
|
public static final int METHOD_HORIZONTAL_VERTICAL = 8;
|
|
public static final int METHOD_VERTICAL_HORIZONTAL = 9;
|
|
public static final int METHOD_CTM_COMPACT = 10;
|
|
public static final int METHOD_OVERLAY = 11;
|
|
public static final int METHOD_OVERLAY_FIXED = 12;
|
|
public static final int METHOD_OVERLAY_RANDOM = 13;
|
|
public static final int METHOD_OVERLAY_REPEAT = 14;
|
|
public static final int METHOD_OVERLAY_CTM = 15;
|
|
public static final int CONNECT_NONE = 0;
|
|
public static final int CONNECT_BLOCK = 1;
|
|
public static final int CONNECT_TILE = 2;
|
|
public static final int CONNECT_MATERIAL = 3;
|
|
public static final int CONNECT_UNKNOWN = 128;
|
|
public static final int FACE_BOTTOM = 1;
|
|
public static final int FACE_TOP = 2;
|
|
public static final int FACE_NORTH = 4;
|
|
public static final int FACE_SOUTH = 8;
|
|
public static final int FACE_WEST = 16;
|
|
public static final int FACE_EAST = 32;
|
|
public static final int FACE_SIDES = 60;
|
|
public static final int FACE_ALL = 63;
|
|
public static final int FACE_UNKNOWN = 128;
|
|
public static final int SYMMETRY_NONE = 1;
|
|
public static final int SYMMETRY_OPPOSITE = 2;
|
|
public static final int SYMMETRY_ALL = 6;
|
|
public static final int SYMMETRY_UNKNOWN = 128;
|
|
public static final String TILE_SKIP_PNG = "<skip>.png";
|
|
public static final String TILE_DEFAULT_PNG = "<default>.png";
|
|
|
|
public ConnectedProperties(Properties props, String path) {
|
|
ConnectedParser connectedparser = new ConnectedParser("ConnectedTextures");
|
|
this.name = connectedparser.parseName(path);
|
|
this.basePath = connectedparser.parseBasePath(path);
|
|
this.matchBlocks = connectedparser.parseMatchBlocks(props.getProperty("matchBlocks"));
|
|
this.metadatas = connectedparser.parseIntList(props.getProperty("metadata"));
|
|
this.matchTiles = this.parseMatchTiles(props.getProperty("matchTiles"));
|
|
this.method = parseMethod(props.getProperty("method"));
|
|
this.tiles = this.parseTileNames(props.getProperty("tiles"));
|
|
this.connect = parseConnect(props.getProperty("connect"));
|
|
this.faces = parseFaces(props.getProperty("faces"));
|
|
this.biomes = connectedparser.parseBiomes(props.getProperty("biomes"));
|
|
this.heights = connectedparser.parseRangeListInt(props.getProperty("heights"));
|
|
|
|
if (this.heights == null) {
|
|
int i = connectedparser.parseInt(props.getProperty("minHeight"), -1);
|
|
int j = connectedparser.parseInt(props.getProperty("maxHeight"), 1024);
|
|
|
|
if (i != -1 || j != 1024) {
|
|
this.heights = new RangeListInt(new RangeInt(i, j));
|
|
}
|
|
}
|
|
|
|
this.renderPass = connectedparser.parseInt(props.getProperty("renderPass"), -1);
|
|
this.innerSeams = connectedparser.parseBoolean(props.getProperty("innerSeams"), false);
|
|
this.ctmTileIndexes = this.parseCtmTileIndexes(props);
|
|
this.width = connectedparser.parseInt(props.getProperty("width"), -1);
|
|
this.height = connectedparser.parseInt(props.getProperty("height"), -1);
|
|
this.weights = connectedparser.parseIntList(props.getProperty("weights"));
|
|
this.randomLoops = connectedparser.parseInt(props.getProperty("randomLoops"), 0);
|
|
this.symmetry = parseSymmetry(props.getProperty("symmetry"));
|
|
this.linked = connectedparser.parseBoolean(props.getProperty("linked"), false);
|
|
this.nbtName = connectedparser.parseNbtTagValue("name", props.getProperty("name"));
|
|
this.connectBlocks = connectedparser.parseMatchBlocks(props.getProperty("connectBlocks"));
|
|
this.connectTiles = this.parseMatchTiles(props.getProperty("connectTiles"));
|
|
this.tintIndex = connectedparser.parseInt(props.getProperty("tintIndex"), -1);
|
|
this.tintBlockState = connectedparser.parseBlockState(props.getProperty("tintBlock"),
|
|
Blocks.air.getDefaultState());
|
|
this.layer = connectedparser.parseBlockRenderLayer(props.getProperty("layer"),
|
|
EnumWorldBlockLayer.CUTOUT_MIPPED);
|
|
}
|
|
|
|
private int[] parseCtmTileIndexes(Properties props) {
|
|
if (this.tiles == null) {
|
|
return null;
|
|
} else {
|
|
Map<Integer, Integer> map = new HashMap();
|
|
|
|
for (Object object : props.keySet()) {
|
|
if (object instanceof String) {
|
|
String s = (String) object;
|
|
String s1 = "ctm.";
|
|
|
|
if (s.startsWith(s1)) {
|
|
String s2 = s.substring(s1.length());
|
|
String s3 = props.getProperty(s);
|
|
|
|
if (s3 != null) {
|
|
s3 = s3.trim();
|
|
int i = Config.parseInt(s2, -1);
|
|
|
|
if (i >= 0 && i <= 46) {
|
|
int j = Config.parseInt(s3, -1);
|
|
|
|
if (j >= 0 && j < this.tiles.length) {
|
|
map.put(Integer.valueOf(i), Integer.valueOf(j));
|
|
} else {
|
|
Config.warn("Invalid CTM tile index: " + s3);
|
|
}
|
|
} else {
|
|
Config.warn("Invalid CTM index: " + s2);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (map.isEmpty()) {
|
|
return null;
|
|
} else {
|
|
int[] aint = new int[47];
|
|
|
|
for (int k = 0; k < aint.length; ++k) {
|
|
aint[k] = -1;
|
|
|
|
if (map.containsKey(Integer.valueOf(k))) {
|
|
aint[k] = ((Integer) map.get(Integer.valueOf(k))).intValue();
|
|
}
|
|
}
|
|
|
|
return aint;
|
|
}
|
|
}
|
|
}
|
|
|
|
private String[] parseMatchTiles(String str) {
|
|
if (str == null) {
|
|
return null;
|
|
} else {
|
|
String[] astring = Config.tokenize(str, " ");
|
|
|
|
for (int i = 0; i < astring.length; ++i) {
|
|
String s = astring[i];
|
|
|
|
if (s.endsWith(".png")) {
|
|
s = s.substring(0, s.length() - 4);
|
|
}
|
|
|
|
s = TextureUtils.fixResourcePath(s, this.basePath);
|
|
astring[i] = s;
|
|
}
|
|
|
|
return astring;
|
|
}
|
|
}
|
|
|
|
private static String parseName(String path) {
|
|
String s = path;
|
|
int i = path.lastIndexOf(47);
|
|
|
|
if (i >= 0) {
|
|
s = path.substring(i + 1);
|
|
}
|
|
|
|
int j = s.lastIndexOf(46);
|
|
|
|
if (j >= 0) {
|
|
s = s.substring(0, j);
|
|
}
|
|
|
|
return s;
|
|
}
|
|
|
|
private static String parseBasePath(String path) {
|
|
int i = path.lastIndexOf(47);
|
|
return i < 0 ? "" : path.substring(0, i);
|
|
}
|
|
|
|
private String[] parseTileNames(String str) {
|
|
if (str == null) {
|
|
return null;
|
|
} else {
|
|
List list = new ArrayList();
|
|
String[] astring = Config.tokenize(str, " ,");
|
|
label32:
|
|
|
|
for (int i = 0; i < astring.length; ++i) {
|
|
String s = astring[i];
|
|
|
|
if (s.contains("-")) {
|
|
String[] astring1 = Config.tokenize(s, "-");
|
|
|
|
if (astring1.length == 2) {
|
|
int j = Config.parseInt(astring1[0], -1);
|
|
int k = Config.parseInt(astring1[1], -1);
|
|
|
|
if (j >= 0 && k >= 0) {
|
|
if (j > k) {
|
|
Config.warn("Invalid interval: " + s + ", when parsing: " + str);
|
|
continue;
|
|
}
|
|
|
|
int l = j;
|
|
|
|
while (true) {
|
|
if (l > k) {
|
|
continue label32;
|
|
}
|
|
|
|
list.add(String.valueOf(l));
|
|
++l;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
list.add(s);
|
|
}
|
|
|
|
String[] astring2 = (String[]) list.toArray(new String[list.size()]);
|
|
|
|
for (int i1 = 0; i1 < astring2.length; ++i1) {
|
|
String s1 = astring2[i1];
|
|
s1 = TextureUtils.fixResourcePath(s1, this.basePath);
|
|
|
|
if (!s1.startsWith(this.basePath) && !s1.startsWith("textures/") && !s1.startsWith("mcpatcher/")) {
|
|
s1 = this.basePath + "/" + s1;
|
|
}
|
|
|
|
if (s1.endsWith(".png")) {
|
|
s1 = s1.substring(0, s1.length() - 4);
|
|
}
|
|
|
|
if (s1.startsWith("/")) {
|
|
s1 = s1.substring(1);
|
|
}
|
|
|
|
astring2[i1] = s1;
|
|
}
|
|
|
|
return astring2;
|
|
}
|
|
}
|
|
|
|
private static int parseSymmetry(String str) {
|
|
if (str == null) {
|
|
return 1;
|
|
} else {
|
|
str = str.trim();
|
|
|
|
if (str.equals("opposite")) {
|
|
return 2;
|
|
} else if (str.equals("all")) {
|
|
return 6;
|
|
} else {
|
|
Config.warn("Unknown symmetry: " + str);
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static int parseFaces(String str) {
|
|
if (str == null) {
|
|
return 63;
|
|
} else {
|
|
String[] astring = Config.tokenize(str, " ,");
|
|
int i = 0;
|
|
|
|
for (int j = 0; j < astring.length; ++j) {
|
|
String s = astring[j];
|
|
int k = parseFace(s);
|
|
i |= k;
|
|
}
|
|
|
|
return i;
|
|
}
|
|
}
|
|
|
|
private static int parseFace(String str) {
|
|
str = str.toLowerCase();
|
|
|
|
if (!str.equals("bottom") && !str.equals("down")) {
|
|
if (!str.equals("top") && !str.equals("up")) {
|
|
if (str.equals("north")) {
|
|
return 4;
|
|
} else if (str.equals("south")) {
|
|
return 8;
|
|
} else if (str.equals("east")) {
|
|
return 32;
|
|
} else if (str.equals("west")) {
|
|
return 16;
|
|
} else if (str.equals("sides")) {
|
|
return 60;
|
|
} else if (str.equals("all")) {
|
|
return 63;
|
|
} else {
|
|
Config.warn("Unknown face: " + str);
|
|
return 128;
|
|
}
|
|
} else {
|
|
return 2;
|
|
}
|
|
} else {
|
|
return 1;
|
|
}
|
|
}
|
|
|
|
private static int parseConnect(String str) {
|
|
if (str == null) {
|
|
return 0;
|
|
} else {
|
|
str = str.trim();
|
|
|
|
if (str.equals("block")) {
|
|
return 1;
|
|
} else if (str.equals("tile")) {
|
|
return 2;
|
|
} else if (str.equals("material")) {
|
|
return 3;
|
|
} else {
|
|
Config.warn("Unknown connect: " + str);
|
|
return 128;
|
|
}
|
|
}
|
|
}
|
|
|
|
public static IProperty getProperty(String key, Collection properties) {
|
|
for (Object iproperty0 : properties) {
|
|
IProperty iproperty = (IProperty) iproperty0;
|
|
if (key.equals(iproperty.getName())) {
|
|
return iproperty;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
private static int parseMethod(String str) {
|
|
if (str == null) {
|
|
return 1;
|
|
} else {
|
|
str = str.trim();
|
|
|
|
if (!str.equals("ctm") && !str.equals("glass")) {
|
|
if (str.equals("ctm_compact")) {
|
|
return 10;
|
|
} else if (!str.equals("horizontal") && !str.equals("bookshelf")) {
|
|
if (str.equals("vertical")) {
|
|
return 6;
|
|
} else if (str.equals("top")) {
|
|
return 3;
|
|
} else if (str.equals("random")) {
|
|
return 4;
|
|
} else if (str.equals("repeat")) {
|
|
return 5;
|
|
} else if (str.equals("fixed")) {
|
|
return 7;
|
|
} else if (!str.equals("horizontal+vertical") && !str.equals("h+v")) {
|
|
if (!str.equals("vertical+horizontal") && !str.equals("v+h")) {
|
|
if (str.equals("overlay")) {
|
|
return 11;
|
|
} else if (str.equals("overlay_fixed")) {
|
|
return 12;
|
|
} else if (str.equals("overlay_random")) {
|
|
return 13;
|
|
} else if (str.equals("overlay_repeat")) {
|
|
return 14;
|
|
} else if (str.equals("overlay_ctm")) {
|
|
return 15;
|
|
} else {
|
|
Config.warn("Unknown method: " + str);
|
|
return 0;
|
|
}
|
|
} else {
|
|
return 9;
|
|
}
|
|
} else {
|
|
return 8;
|
|
}
|
|
} else {
|
|
return 2;
|
|
}
|
|
} else {
|
|
return 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
public boolean isValid(String path) {
|
|
if (this.name != null && this.name.length() > 0) {
|
|
if (this.basePath == null) {
|
|
Config.warn("No base path found: " + path);
|
|
return false;
|
|
} else {
|
|
if (this.matchBlocks == null) {
|
|
this.matchBlocks = this.detectMatchBlocks();
|
|
}
|
|
|
|
if (this.matchTiles == null && this.matchBlocks == null) {
|
|
this.matchTiles = this.detectMatchTiles();
|
|
}
|
|
|
|
if (this.matchBlocks == null && this.matchTiles == null) {
|
|
Config.warn("No matchBlocks or matchTiles specified: " + path);
|
|
return false;
|
|
} else if (this.method == 0) {
|
|
Config.warn("No method: " + path);
|
|
return false;
|
|
} else if (this.tiles != null && this.tiles.length > 0) {
|
|
if (this.connect == 0) {
|
|
this.connect = this.detectConnect();
|
|
}
|
|
|
|
if (this.connect == 128) {
|
|
Config.warn("Invalid connect in: " + path);
|
|
return false;
|
|
} else if (this.renderPass > 0) {
|
|
Config.warn("Render pass not supported: " + this.renderPass);
|
|
return false;
|
|
} else if ((this.faces & 128) != 0) {
|
|
Config.warn("Invalid faces in: " + path);
|
|
return false;
|
|
} else if ((this.symmetry & 128) != 0) {
|
|
Config.warn("Invalid symmetry in: " + path);
|
|
return false;
|
|
} else {
|
|
switch (this.method) {
|
|
case 1:
|
|
return this.isValidCtm(path);
|
|
|
|
case 2:
|
|
return this.isValidHorizontal(path);
|
|
|
|
case 3:
|
|
return this.isValidTop(path);
|
|
|
|
case 4:
|
|
return this.isValidRandom(path);
|
|
|
|
case 5:
|
|
return this.isValidRepeat(path);
|
|
|
|
case 6:
|
|
return this.isValidVertical(path);
|
|
|
|
case 7:
|
|
return this.isValidFixed(path);
|
|
|
|
case 8:
|
|
return this.isValidHorizontalVertical(path);
|
|
|
|
case 9:
|
|
return this.isValidVerticalHorizontal(path);
|
|
|
|
case 10:
|
|
return this.isValidCtmCompact(path);
|
|
|
|
case 11:
|
|
return this.isValidOverlay(path);
|
|
|
|
case 12:
|
|
return this.isValidOverlayFixed(path);
|
|
|
|
case 13:
|
|
return this.isValidOverlayRandom(path);
|
|
|
|
case 14:
|
|
return this.isValidOverlayRepeat(path);
|
|
|
|
case 15:
|
|
return this.isValidOverlayCtm(path);
|
|
|
|
default:
|
|
Config.warn("Unknown method: " + path);
|
|
return false;
|
|
}
|
|
}
|
|
} else {
|
|
Config.warn("No tiles specified: " + path);
|
|
return false;
|
|
}
|
|
}
|
|
} else {
|
|
Config.warn("No name found: " + path);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private int detectConnect() {
|
|
return this.matchBlocks != null ? 1 : (this.matchTiles != null ? 2 : 128);
|
|
}
|
|
|
|
private MatchBlock[] detectMatchBlocks() {
|
|
int[] aint = this.detectMatchBlockIds();
|
|
|
|
if (aint == null) {
|
|
return null;
|
|
} else {
|
|
MatchBlock[] amatchblock = new MatchBlock[aint.length];
|
|
|
|
for (int i = 0; i < amatchblock.length; ++i) {
|
|
amatchblock[i] = new MatchBlock(aint[i]);
|
|
}
|
|
|
|
return amatchblock;
|
|
}
|
|
}
|
|
|
|
private int[] detectMatchBlockIds() {
|
|
if (!this.name.startsWith("block")) {
|
|
return null;
|
|
} else {
|
|
int i = "block".length();
|
|
int j;
|
|
|
|
for (j = i; j < this.name.length(); ++j) {
|
|
char c0 = this.name.charAt(j);
|
|
|
|
if (c0 < 48 || c0 > 57) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (j == i) {
|
|
return null;
|
|
} else {
|
|
String s = this.name.substring(i, j);
|
|
int k = Config.parseInt(s, -1);
|
|
return k < 0 ? null : new int[] { k };
|
|
}
|
|
}
|
|
}
|
|
|
|
private String[] detectMatchTiles() {
|
|
EaglerTextureAtlasSprite textureatlassprite = getIcon(this.name);
|
|
return textureatlassprite == null ? null : new String[] { this.name };
|
|
}
|
|
|
|
private static EaglerTextureAtlasSprite getIcon(String iconName) {
|
|
TextureMap texturemap = Minecraft.getMinecraft().getTextureMapBlocks();
|
|
EaglerTextureAtlasSprite textureatlassprite = texturemap.getSpriteSafe(iconName);
|
|
|
|
if (textureatlassprite != null) {
|
|
return textureatlassprite;
|
|
} else {
|
|
textureatlassprite = texturemap.getSpriteSafe("blocks/" + iconName);
|
|
return textureatlassprite;
|
|
}
|
|
}
|
|
|
|
private boolean isValidCtm(String path) {
|
|
if (this.tiles == null) {
|
|
this.tiles = this.parseTileNames("0-11 16-27 32-43 48-58");
|
|
}
|
|
|
|
if (this.tiles.length < 47) {
|
|
Config.warn("Invalid tiles, must be at least 47: " + path);
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
private boolean isValidCtmCompact(String path) {
|
|
if (this.tiles == null) {
|
|
this.tiles = this.parseTileNames("0-4");
|
|
}
|
|
|
|
if (this.tiles.length < 5) {
|
|
Config.warn("Invalid tiles, must be at least 5: " + path);
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
private boolean isValidOverlay(String path) {
|
|
if (this.tiles == null) {
|
|
this.tiles = this.parseTileNames("0-16");
|
|
}
|
|
|
|
if (this.tiles.length < 17) {
|
|
Config.warn("Invalid tiles, must be at least 17: " + path);
|
|
return false;
|
|
} else if (this.layer != null && this.layer != EnumWorldBlockLayer.SOLID) {
|
|
return true;
|
|
} else {
|
|
Config.warn("Invalid overlay layer: " + this.layer);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private boolean isValidOverlayFixed(String path) {
|
|
if (!this.isValidFixed(path)) {
|
|
return false;
|
|
} else if (this.layer != null && this.layer != EnumWorldBlockLayer.SOLID) {
|
|
return true;
|
|
} else {
|
|
Config.warn("Invalid overlay layer: " + this.layer);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private boolean isValidOverlayRandom(String path) {
|
|
if (!this.isValidRandom(path)) {
|
|
return false;
|
|
} else if (this.layer != null && this.layer != EnumWorldBlockLayer.SOLID) {
|
|
return true;
|
|
} else {
|
|
Config.warn("Invalid overlay layer: " + this.layer);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private boolean isValidOverlayRepeat(String path) {
|
|
if (!this.isValidRepeat(path)) {
|
|
return false;
|
|
} else if (this.layer != null && this.layer != EnumWorldBlockLayer.SOLID) {
|
|
return true;
|
|
} else {
|
|
Config.warn("Invalid overlay layer: " + this.layer);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private boolean isValidOverlayCtm(String path) {
|
|
if (!this.isValidCtm(path)) {
|
|
return false;
|
|
} else if (this.layer != null && this.layer != EnumWorldBlockLayer.SOLID) {
|
|
return true;
|
|
} else {
|
|
Config.warn("Invalid overlay layer: " + this.layer);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private boolean isValidHorizontal(String path) {
|
|
if (this.tiles == null) {
|
|
this.tiles = this.parseTileNames("12-15");
|
|
}
|
|
|
|
if (this.tiles.length != 4) {
|
|
Config.warn("Invalid tiles, must be exactly 4: " + path);
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
private boolean isValidVertical(String path) {
|
|
if (this.tiles == null) {
|
|
Config.warn("No tiles defined for vertical: " + path);
|
|
return false;
|
|
} else if (this.tiles.length != 4) {
|
|
Config.warn("Invalid tiles, must be exactly 4: " + path);
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
private boolean isValidHorizontalVertical(String path) {
|
|
if (this.tiles == null) {
|
|
Config.warn("No tiles defined for horizontal+vertical: " + path);
|
|
return false;
|
|
} else if (this.tiles.length != 7) {
|
|
Config.warn("Invalid tiles, must be exactly 7: " + path);
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
private boolean isValidVerticalHorizontal(String path) {
|
|
if (this.tiles == null) {
|
|
Config.warn("No tiles defined for vertical+horizontal: " + path);
|
|
return false;
|
|
} else if (this.tiles.length != 7) {
|
|
Config.warn("Invalid tiles, must be exactly 7: " + path);
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
private boolean isValidRandom(String path) {
|
|
if (this.tiles != null && this.tiles.length > 0) {
|
|
if (this.weights != null) {
|
|
if (this.weights.length > this.tiles.length) {
|
|
Config.warn("More weights defined than tiles, trimming weights: " + path);
|
|
int[] aint = new int[this.tiles.length];
|
|
System.arraycopy(this.weights, 0, aint, 0, aint.length);
|
|
this.weights = aint;
|
|
}
|
|
|
|
if (this.weights.length < this.tiles.length) {
|
|
Config.warn("Less weights defined than tiles, expanding weights: " + path);
|
|
int[] aint1 = new int[this.tiles.length];
|
|
System.arraycopy(this.weights, 0, aint1, 0, this.weights.length);
|
|
int i = MathUtils.getAverage(this.weights);
|
|
|
|
for (int j = this.weights.length; j < aint1.length; ++j) {
|
|
aint1[j] = i;
|
|
}
|
|
|
|
this.weights = aint1;
|
|
}
|
|
|
|
this.sumWeights = new int[this.weights.length];
|
|
int k = 0;
|
|
|
|
for (int l = 0; l < this.weights.length; ++l) {
|
|
k += this.weights[l];
|
|
this.sumWeights[l] = k;
|
|
}
|
|
|
|
this.sumAllWeights = k;
|
|
|
|
if (this.sumAllWeights <= 0) {
|
|
Config.warn("Invalid sum of all weights: " + k);
|
|
this.sumAllWeights = 1;
|
|
}
|
|
}
|
|
|
|
if (this.randomLoops >= 0 && this.randomLoops <= 9) {
|
|
return true;
|
|
} else {
|
|
Config.warn("Invalid randomLoops: " + this.randomLoops);
|
|
return false;
|
|
}
|
|
} else {
|
|
Config.warn("Tiles not defined: " + path);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private boolean isValidRepeat(String path) {
|
|
if (this.tiles == null) {
|
|
Config.warn("Tiles not defined: " + path);
|
|
return false;
|
|
} else if (this.width <= 0) {
|
|
Config.warn("Invalid width: " + path);
|
|
return false;
|
|
} else if (this.height <= 0) {
|
|
Config.warn("Invalid height: " + path);
|
|
return false;
|
|
} else if (this.tiles.length != this.width * this.height) {
|
|
Config.warn("Number of tiles does not equal width x height: " + path);
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
private boolean isValidFixed(String path) {
|
|
if (this.tiles == null) {
|
|
Config.warn("Tiles not defined: " + path);
|
|
return false;
|
|
} else if (this.tiles.length != 1) {
|
|
Config.warn("Number of tiles should be 1 for method: fixed.");
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
private boolean isValidTop(String path) {
|
|
if (this.tiles == null) {
|
|
this.tiles = this.parseTileNames("66");
|
|
}
|
|
|
|
if (this.tiles.length != 1) {
|
|
Config.warn("Invalid tiles, must be exactly 1: " + path);
|
|
return false;
|
|
} else {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public void updateIcons(TextureMap textureMap) {
|
|
String baseName = null;
|
|
if (this.matchTiles != null) {
|
|
this.matchTileIcons = registerIcons(this.matchTiles, null, textureMap, false, false);
|
|
if(this.matchTiles.length > 0) {
|
|
baseName = "blocks/" + this.matchTiles[0];
|
|
}
|
|
}
|
|
|
|
if(baseName == null) {
|
|
int blockBaseID = -1;
|
|
int metaBase = -1;
|
|
if(this.matchBlocks != null && this.matchBlocks.length > 0) {
|
|
MatchBlock b = this.matchBlocks[0];
|
|
blockBaseID = b.getBlockId();
|
|
int[] metas = b.getMetadatas();
|
|
if(metas != null && metas.length > 0) {
|
|
metaBase = metas[0];
|
|
}
|
|
}
|
|
if(blockBaseID != -1) {
|
|
if(metaBase == -1 && this.metadatas != null && this.metadatas.length > 0) {
|
|
metaBase = this.metadatas[0];
|
|
}
|
|
if(metaBase == -1) {
|
|
metaBase = 0;
|
|
}
|
|
baseName = Minecraft.getMinecraft().getModelManager().modelbakerytmp.getBaseTextureForBlockPre(blockBaseID, metaBase);
|
|
}
|
|
}
|
|
|
|
if (this.connectTiles != null) {
|
|
this.connectTileIcons = registerIcons(this.connectTiles, baseName, textureMap, false, false);
|
|
}
|
|
|
|
if (this.tiles != null) {
|
|
this.tileIcons = registerIcons(this.tiles, baseName, textureMap, true, !isMethodOverlay(this.method));
|
|
}
|
|
}
|
|
|
|
private static boolean isMethodOverlay(int method) {
|
|
switch (method) {
|
|
case 11:
|
|
case 12:
|
|
case 13:
|
|
case 14:
|
|
case 15:
|
|
return true;
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
private static EaglerTextureAtlasSprite[] registerIcons(String[] tileNames, String baseName,
|
|
TextureMap textureMap, boolean skipTiles, boolean defaultTiles) {
|
|
if (tileNames == null) {
|
|
return null;
|
|
} else {
|
|
List list = new ArrayList();
|
|
|
|
for (int i = 0; i < tileNames.length; ++i) {
|
|
String s = tileNames[i];
|
|
ResourceLocation resourcelocation = new ResourceLocation(s);
|
|
String s1 = resourcelocation.getResourceDomain();
|
|
String s2 = resourcelocation.getResourcePath();
|
|
|
|
if (!s2.contains("/")) {
|
|
s2 = "textures/blocks/" + s2;
|
|
}
|
|
|
|
String s3 = s2 + ".png";
|
|
|
|
if (skipTiles && s3.endsWith("<skip>.png")) {
|
|
list.add(null);
|
|
} else if (defaultTiles && s3.endsWith("<default>.png")) {
|
|
list.add(ConnectedTextures.SPRITE_DEFAULT);
|
|
} else {
|
|
ResourceLocation resourcelocation1 = new ResourceLocation(s1, s3);
|
|
boolean flag = Config.hasResource(resourcelocation1);
|
|
|
|
if (!flag) {
|
|
Config.warn("File not found: " + s3);
|
|
}
|
|
|
|
String s4 = "textures/";
|
|
String s5 = s2;
|
|
|
|
if (s2.startsWith(s4)) {
|
|
s5 = s2.substring(s4.length());
|
|
}
|
|
|
|
ResourceLocation resourcelocation2 = new ResourceLocation(s1, s5);
|
|
EaglerTextureAtlasSprite textureatlassprite = textureMap.registerSprite(resourcelocation2, baseName);
|
|
list.add(textureatlassprite);
|
|
}
|
|
}
|
|
|
|
EaglerTextureAtlasSprite[] atextureatlassprite = (EaglerTextureAtlasSprite[]) list
|
|
.toArray(new EaglerTextureAtlasSprite[list.size()]);
|
|
return atextureatlassprite;
|
|
}
|
|
}
|
|
|
|
public boolean matchesBlockId(int blockId) {
|
|
return Matches.blockId(blockId, this.matchBlocks);
|
|
}
|
|
|
|
public boolean matchesBlock(int blockId, int metadata) {
|
|
return !Matches.block(blockId, metadata, this.matchBlocks) ? false : Matches.metadata(metadata, this.metadatas);
|
|
}
|
|
|
|
public boolean matchesIcon(EaglerTextureAtlasSprite icon) {
|
|
return Matches.sprite(icon, this.matchTileIcons);
|
|
}
|
|
|
|
public String toString() {
|
|
return "CTM name: " + this.name + ", basePath: " + this.basePath + ", matchBlocks: "
|
|
+ Config.arrayToString((Object[]) this.matchBlocks) + ", matchTiles: "
|
|
+ Config.arrayToString((Object[]) this.matchTiles);
|
|
}
|
|
|
|
public boolean matchesBiome(BiomeGenBase biome) {
|
|
return Matches.biome(biome, this.biomes);
|
|
}
|
|
|
|
public int getMetadataMax() {
|
|
int i = -1;
|
|
i = this.getMax(this.metadatas, i);
|
|
|
|
if (this.matchBlocks != null) {
|
|
for (int j = 0; j < this.matchBlocks.length; ++j) {
|
|
MatchBlock matchblock = this.matchBlocks[j];
|
|
i = this.getMax(matchblock.getMetadatas(), i);
|
|
}
|
|
}
|
|
|
|
return i;
|
|
}
|
|
|
|
private int getMax(int[] mds, int max) {
|
|
if (mds == null) {
|
|
return max;
|
|
} else {
|
|
for (int i = 0; i < mds.length; ++i) {
|
|
int j = mds[i];
|
|
|
|
if (j > max) {
|
|
max = j;
|
|
}
|
|
}
|
|
|
|
return max;
|
|
}
|
|
}
|
|
}
|