mirror of
https://github.com/xfl03/MCCustomSkinLoader.git
synced 2026-11-20 06:29:38 +00:00
Remove: all vanilla editions
This commit is contained in:
1 parent
c2dad72690
commit
755f7647ed
136 files changed
+113
-1355
No files matched your search
@@ -0,0 +1,254 @@
|
||||
package customskinloader;
|
||||
|
||||
import java.io.File;
|
||||
import java.util.Map;
|
||||
import java.util.concurrent.ExecutorService;
|
||||
import java.util.concurrent.Executors;
|
||||
import java.util.concurrent.LinkedBlockingQueue;
|
||||
import java.util.concurrent.ThreadFactory;
|
||||
import java.util.concurrent.ThreadPoolExecutor;
|
||||
import java.util.concurrent.TimeUnit;
|
||||
import java.util.function.Consumer;
|
||||
|
||||
import com.google.common.collect.Maps;
|
||||
import com.google.gson.Gson;
|
||||
import com.google.gson.GsonBuilder;
|
||||
import com.mojang.authlib.GameProfile;
|
||||
import com.mojang.authlib.minecraft.MinecraftProfileTexture;
|
||||
import customskinloader.config.Config;
|
||||
import customskinloader.config.SkinSiteProfile;
|
||||
import customskinloader.loader.ProfileLoader;
|
||||
import customskinloader.log.LogManager;
|
||||
import customskinloader.log.Logger;
|
||||
import customskinloader.profile.DynamicSkullManager;
|
||||
import customskinloader.profile.ModelManager0;
|
||||
import customskinloader.profile.ProfileCache;
|
||||
import customskinloader.profile.UserProfile;
|
||||
import customskinloader.utils.MinecraftUtil;
|
||||
|
||||
/**
|
||||
* Custom skin loader mod for Minecraft.
|
||||
*
|
||||
* @author Jeremy Lam [JLChnToZ] 2013-2014 & Alexander Xia [xfl03] 2014-2023
|
||||
* @version @MOD_FULL_VERSION@
|
||||
*/
|
||||
public class CustomSkinLoader {
|
||||
public static final String CustomSkinLoader_VERSION = "@MOD_VERSION@";
|
||||
public static final String CustomSkinLoader_FULL_VERSION = "@MOD_FULL_VERSION@";
|
||||
public static final int CustomSkinLoader_BUILD_NUMBER = Integer.parseInt("@MOD_BUILD_NUMBER@");
|
||||
|
||||
public static final File
|
||||
DATA_DIR = new File(MinecraftUtil.getMinecraftDataDir(), "CustomSkinLoader"),
|
||||
LOG_FILE = new File(DATA_DIR, "CustomSkinLoader.log"),
|
||||
CONFIG_FILE = new File(DATA_DIR, "CustomSkinLoader.json");
|
||||
|
||||
public static final Gson GSON = new GsonBuilder().setPrettyPrinting().create();
|
||||
public static final Logger logger = initLogger();
|
||||
public static final Config config = initConfig();
|
||||
|
||||
private static final ProfileCache profileCache = new ProfileCache();
|
||||
private static final DynamicSkullManager dynamicSkullManager = new DynamicSkullManager();
|
||||
|
||||
private static final ExecutorService THREAD_POOL = new ThreadPoolExecutor(
|
||||
config.threadPoolSize, config.threadPoolSize, 1L, TimeUnit.MINUTES, new LinkedBlockingQueue<>());
|
||||
|
||||
//Correct thread name in thread pool
|
||||
private static final ThreadFactory defaultFactory = Executors.defaultThreadFactory();
|
||||
private static final ThreadFactory customFactory = r -> {
|
||||
Thread t = defaultFactory.newThread(r);
|
||||
if (r instanceof Thread) {
|
||||
t.setName(((Thread) r).getName());
|
||||
}
|
||||
return t;
|
||||
};
|
||||
//Thread pool will discard oldest task when queue reaches 333 tasks
|
||||
private static final ThreadPoolExecutor threadPool = new ThreadPoolExecutor(
|
||||
config.threadPoolSize, config.threadPoolSize, 1L, TimeUnit.MINUTES,
|
||||
new LinkedBlockingQueue<>(333), customFactory, new ThreadPoolExecutor.DiscardOldestPolicy()
|
||||
);
|
||||
|
||||
public static void loadProfileTextures(Runnable runnable) {
|
||||
THREAD_POOL.execute(runnable);
|
||||
}
|
||||
|
||||
public static void loadProfileLazily(
|
||||
GameProfile gameProfile, Consumer<Map<MinecraftProfileTexture.Type, MinecraftProfileTexture>> consumer) {
|
||||
String username = gameProfile.getName();
|
||||
String credential = MinecraftUtil.getCredential(gameProfile);
|
||||
// Fix: http://hopper.minecraft.net/crashes/minecraft/MCX-2773713
|
||||
if (username == null) {
|
||||
logger.warning("Could not load profile: username is null.");
|
||||
consumer.accept(Maps.newHashMap());
|
||||
return;
|
||||
}
|
||||
String tempName = Thread.currentThread().getName();
|
||||
Thread.currentThread().setName(username); // Change Thread Name
|
||||
if (profileCache.isLoading(credential)) {
|
||||
profileCache.putLoader(credential, consumer);
|
||||
Thread.currentThread().setName(tempName);
|
||||
return;
|
||||
}
|
||||
consumer.accept(loadProfile(gameProfile));
|
||||
Thread.currentThread().setName(tempName);
|
||||
profileCache.getLastLoader(credential).ifPresent(c -> loadProfileLazily(gameProfile, c));
|
||||
}
|
||||
|
||||
//For User Skin
|
||||
public static Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> loadProfile(GameProfile gameProfile) {
|
||||
String credential = MinecraftUtil.getCredential(gameProfile);
|
||||
UserProfile profile;
|
||||
if (profileCache.isReady(credential)) {
|
||||
logger.info("Cached profile will be used.");
|
||||
profile = profileCache.getProfile(credential);
|
||||
if (profile == null) {
|
||||
logger.warning("(Cached Profile is empty!) Expiry: " + profileCache.getExpiry(credential));
|
||||
if (profileCache.isExpired(credential)) { // force load
|
||||
profile = loadProfile0(gameProfile, false);
|
||||
}
|
||||
} else {
|
||||
logger.info(profile.toString(profileCache.getExpiry(credential)));
|
||||
}
|
||||
} else {
|
||||
profileCache.setLoading(credential, true);
|
||||
profile = loadProfile0(gameProfile, false);
|
||||
}
|
||||
return ModelManager0.fromUserProfile(profile);
|
||||
}
|
||||
|
||||
//Core
|
||||
public static UserProfile loadProfile0(GameProfile gameProfile, boolean isSkull) {
|
||||
String username = gameProfile.getName();
|
||||
String credential = MinecraftUtil.getCredential(gameProfile);
|
||||
|
||||
profileCache.setLoading(credential, true);
|
||||
logger.info("Loading " + username + "'s profile.");
|
||||
if (config.loadlist == null || config.loadlist.isEmpty()) {
|
||||
logger.info("LoadList is Empty.");
|
||||
return null;
|
||||
}
|
||||
|
||||
UserProfile profile0 = new UserProfile();
|
||||
for (int i = 0; i < config.loadlist.size(); i++) {
|
||||
SkinSiteProfile ssp = config.loadlist.get(i);
|
||||
logger.info((i + 1) + "/" + config.loadlist.size() + " Try to load profile from '" + ssp.name + "'.");
|
||||
if (ssp.type == null) {
|
||||
logger.info("The type of '" + ssp.name + "' is null.");
|
||||
continue;
|
||||
}
|
||||
ProfileLoader.IProfileLoader loader = ProfileLoader.LOADERS.get(ssp.type.toLowerCase());
|
||||
if (loader == null) {
|
||||
logger.info("Type '" + ssp.type + "' is not defined.");
|
||||
continue;
|
||||
}
|
||||
UserProfile profile = null;
|
||||
try {
|
||||
profile = loader.loadProfile(ssp, gameProfile);
|
||||
} catch (Exception e) {
|
||||
logger.warning("Exception occurs while loading.");
|
||||
logger.warning(e);
|
||||
if (e.getCause() != null) {
|
||||
logger.warning("Caused By:");
|
||||
logger.warning(e.getCause());
|
||||
}
|
||||
}
|
||||
if (profile == null) {
|
||||
continue;
|
||||
}
|
||||
profile0.mix(profile);
|
||||
if (isSkull && !profile0.hasSkinUrl()) {
|
||||
continue;
|
||||
}
|
||||
if (!config.forceLoadAllTextures) {
|
||||
break;
|
||||
}
|
||||
if (profile0.isFull()) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!profile0.isEmpty()) {
|
||||
logger.info(username + "'s profile loaded.");
|
||||
if (!config.enableCape) {
|
||||
profile0.capeUrl = null;
|
||||
}
|
||||
profileCache.updateCache(credential, profile0);
|
||||
profileCache.setLoading(credential, false);
|
||||
logger.info(profile0.toString(profileCache.getExpiry(credential)));
|
||||
return profile0;
|
||||
}
|
||||
logger.info(username + "'s profile not found in load list.");
|
||||
|
||||
if (config.enableLocalProfileCache) {
|
||||
UserProfile profile = profileCache.getLocalProfile(credential);
|
||||
if (profile == null) {
|
||||
logger.info(username + "'s LocalProfile not found.");
|
||||
} else {
|
||||
profileCache.updateCache(credential, profile, false);
|
||||
profileCache.setLoading(credential, false);
|
||||
logger.info(username + "'s LocalProfile will be used.");
|
||||
logger.info(profile.toString(profileCache.getExpiry(credential)));
|
||||
return profile;
|
||||
}
|
||||
}
|
||||
profileCache.setLoading(credential, false);
|
||||
return null;
|
||||
}
|
||||
|
||||
//For Skull
|
||||
public static Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> loadProfileFromCache(
|
||||
final GameProfile gameProfile) {
|
||||
String username = gameProfile.getName();
|
||||
String credential = MinecraftUtil.getCredential(gameProfile);
|
||||
|
||||
//CustomSkinLoader needs username to load standard skin, if username not exist, only textures in NBT can be used
|
||||
//Authlib 3.11.50 makes empty username to " "
|
||||
if (username == null || username.isEmpty() || username.equals(" ") || credential == null) {
|
||||
return dynamicSkullManager.getTexture(gameProfile);
|
||||
}
|
||||
if (config.forceUpdateSkull ? profileCache.isReady(credential) : profileCache.isExist(credential)) {
|
||||
UserProfile profile = profileCache.getProfile(credential);
|
||||
return ModelManager0.fromUserProfile(profile);
|
||||
}
|
||||
if (!profileCache.isLoading(credential)) {
|
||||
profileCache.setLoading(credential, true);
|
||||
Runnable loadThread = () -> {
|
||||
String tempName = Thread.currentThread().getName();
|
||||
Thread.currentThread().setName(username + "'s skull");
|
||||
loadProfile0(gameProfile, true);//Load in thread
|
||||
Thread.currentThread().setName(tempName);
|
||||
};
|
||||
if (config.forceUpdateSkull) {
|
||||
new Thread(loadThread).start();
|
||||
} else {
|
||||
threadPool.execute(loadThread);
|
||||
}
|
||||
}
|
||||
return Maps.newHashMap();
|
||||
}
|
||||
|
||||
private static Logger initLogger() {
|
||||
LogManager.setLogFile(LOG_FILE.toPath());
|
||||
Logger logger = LogManager.getLogger("Core");
|
||||
logger.info("CustomSkinLoader " + CustomSkinLoader_FULL_VERSION);
|
||||
logger.info("DataDir: " + DATA_DIR.getAbsolutePath());
|
||||
logger.info("Operating System: " + System.getProperty("os.name") +
|
||||
" (" + System.getProperty("os.arch") + ") version " + System.getProperty("os.version"));
|
||||
logger.info("Java Version: " + System.getProperty("java.version") +
|
||||
", " + System.getProperty("java.vendor"));
|
||||
logger.info("Java VM Version: " + System.getProperty("java.vm.name") +
|
||||
" (" + System.getProperty("java.vm.info") + "), " + System.getProperty("java.vm.vendor"));
|
||||
logger.info("Minecraft: " + MinecraftUtil.getMinecraftMainVersion());
|
||||
return logger;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create <code>Config</code> object.
|
||||
* To use <code>logger</code>, please make sure call this function after <code>initLogger</code>.
|
||||
*
|
||||
* @return <code>Config</code>
|
||||
*/
|
||||
private static Config initConfig() {
|
||||
Config config = Config.loadConfig0();
|
||||
logger.enableLogStdOut = config.enableLogStdOut;
|
||||
return config;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
package customskinloader;
|
||||
|
||||
/**
|
||||
* @deprecated From 14.16, use <code>customskinloader.log.Logger</code> instead.
|
||||
*/
|
||||
@Deprecated
|
||||
public class Logger extends customskinloader.log.Logger {
|
||||
}
|
||||
@@ -0,0 +1,259 @@
|
||||
package customskinloader.config;
|
||||
|
||||
import java.io.File;
|
||||
import java.lang.reflect.Field;
|
||||
import java.util.*;
|
||||
|
||||
import customskinloader.CustomSkinLoader;
|
||||
import customskinloader.loader.ProfileLoader;
|
||||
import customskinloader.plugin.ICustomSkinLoaderPlugin;
|
||||
import customskinloader.plugin.PluginLoader;
|
||||
import customskinloader.utils.HttpRequestUtil;
|
||||
import customskinloader.utils.HttpTextureUtil;
|
||||
import customskinloader.utils.HttpUtil0;
|
||||
import customskinloader.utils.Version;
|
||||
import org.apache.commons.io.FileUtils;
|
||||
|
||||
@SuppressWarnings("ResultOfMethodCallIgnored")
|
||||
public class Config {
|
||||
//Program
|
||||
public String version;
|
||||
public int buildNumber;
|
||||
public List<SkinSiteProfile> loadlist;
|
||||
|
||||
//Function
|
||||
public boolean enableDynamicSkull = true;
|
||||
public boolean enableTransparentSkin = true;
|
||||
public boolean forceIgnoreHttpsCertificate = false;
|
||||
public boolean forceLoadAllTextures = true;
|
||||
public boolean enableCape = true;
|
||||
public int threadPoolSize = 8;
|
||||
/**
|
||||
* Can logger write message to standard output(System.out).
|
||||
* Because standard output won't write to latest.log after Forge 1.17,
|
||||
* printing to standard output is meaningless,
|
||||
* which makes this switch default value is <code>false</code>.
|
||||
* @since 14.15
|
||||
*/
|
||||
public boolean enableLogStdOut = false;
|
||||
|
||||
//Profile Cache
|
||||
public int cacheExpiry = 30;
|
||||
public boolean forceUpdateSkull = false;
|
||||
public boolean enableLocalProfileCache = false;
|
||||
|
||||
//Network Cache
|
||||
public boolean enableCacheAutoClean = false;
|
||||
public boolean forceDisableCache = false;
|
||||
|
||||
// Used by Gson to create an instance with default value.
|
||||
public Config() {
|
||||
this(new ArrayList<>());
|
||||
}
|
||||
|
||||
//Init config
|
||||
public Config(List<SkinSiteProfile> loadlist) {
|
||||
this.version = CustomSkinLoader.CustomSkinLoader_VERSION;
|
||||
this.buildNumber = CustomSkinLoader.CustomSkinLoader_BUILD_NUMBER;
|
||||
this.loadlist = loadlist;
|
||||
}
|
||||
|
||||
public static Config loadConfig0() {
|
||||
Config config = loadConfig();
|
||||
|
||||
//LoadList null checker
|
||||
if (config.loadlist == null) {
|
||||
config.loadlist = new ArrayList<>();
|
||||
} else {
|
||||
for (int i = 0; i < config.loadlist.size(); i++) {
|
||||
if (config.loadlist.get(i) == null)
|
||||
config.loadlist.remove(i--);
|
||||
}
|
||||
}
|
||||
|
||||
//Init program
|
||||
config.loadExtraList();
|
||||
config.updateLoadlist();
|
||||
config.initLocalFolder();
|
||||
config.threadPoolSize = Math.max(config.threadPoolSize, 1);
|
||||
if (config.forceIgnoreHttpsCertificate)
|
||||
HttpUtil0.ignoreHttpsCertificate();
|
||||
if (config.enableCacheAutoClean && !config.enableLocalProfileCache) {
|
||||
try {
|
||||
FileUtils.deleteDirectory(HttpRequestUtil.CACHE_DIR);
|
||||
FileUtils.deleteDirectory(HttpTextureUtil.getCacheDir());
|
||||
CustomSkinLoader.logger.info("Successfully cleaned cache.");
|
||||
} catch (Exception e) {
|
||||
CustomSkinLoader.logger.warning("Exception occurs while cleaning cache: " + e);
|
||||
}
|
||||
}
|
||||
|
||||
//Check config version
|
||||
Version configVersion = Version.of(config.version);
|
||||
if (CustomSkinLoader.CustomSkinLoader_BUILD_NUMBER == 0 // Custom builds
|
||||
|| configVersion.compareTo(CustomSkinLoader.CustomSkinLoader_VERSION) < 0
|
||||
|| config.buildNumber < CustomSkinLoader.CustomSkinLoader_BUILD_NUMBER) {
|
||||
CustomSkinLoader.logger.info("Config File is out of date: " + config.version +
|
||||
", build number: " + config.buildNumber);
|
||||
config.version = CustomSkinLoader.CustomSkinLoader_VERSION;
|
||||
config.buildNumber = CustomSkinLoader.CustomSkinLoader_BUILD_NUMBER;
|
||||
}
|
||||
writeConfig(config, true);
|
||||
|
||||
//Output config
|
||||
for (Field field : config.getClass().getDeclaredFields()) {
|
||||
try {
|
||||
Object value = field.get(config);
|
||||
CustomSkinLoader.logger.info(field.getName() + " : " + value);
|
||||
} catch (Exception ignored) {
|
||||
}
|
||||
}
|
||||
|
||||
return config;
|
||||
}
|
||||
|
||||
private static Config loadConfig() {
|
||||
CustomSkinLoader.logger.info("Config File: " + CustomSkinLoader.CONFIG_FILE.getAbsolutePath());
|
||||
if (!CustomSkinLoader.CONFIG_FILE.exists()) {
|
||||
CustomSkinLoader.logger.info("Config file not found, use default instead.");
|
||||
return initConfig();
|
||||
}
|
||||
try {
|
||||
CustomSkinLoader.logger.info("Try to load config.");
|
||||
String json = FileUtils.readFileToString(CustomSkinLoader.CONFIG_FILE, "UTF-8");
|
||||
Config config = Objects.requireNonNull(CustomSkinLoader.GSON.fromJson(json, Config.class));
|
||||
CustomSkinLoader.logger.info("Successfully load config.");
|
||||
return config;
|
||||
} catch (Exception e) {
|
||||
CustomSkinLoader.logger.info("Failed to load config, use default instead.(" + e + ")");
|
||||
createBrokenFile(CustomSkinLoader.CONFIG_FILE);
|
||||
return initConfig();
|
||||
}
|
||||
}
|
||||
|
||||
private void loadExtraList() {
|
||||
File listAddition = new File(CustomSkinLoader.DATA_DIR, "ExtraList");
|
||||
if (!listAddition.isDirectory()) {
|
||||
listAddition.mkdirs();
|
||||
return;
|
||||
}
|
||||
List<SkinSiteProfile> adds = new ArrayList<>();
|
||||
File[] files = listAddition.listFiles();
|
||||
for (File file : files != null ? files : new File[0]) {
|
||||
if (!file.getName().toLowerCase().endsWith(".json") && !file.getName().toLowerCase().endsWith(".txt"))
|
||||
continue;
|
||||
try {
|
||||
CustomSkinLoader.logger.info("Try to load Extra List.(" + file.getName() + ")");
|
||||
String json = FileUtils.readFileToString(file, "UTF-8");
|
||||
SkinSiteProfile ssp = CustomSkinLoader.GSON.fromJson(json, SkinSiteProfile.class);
|
||||
CustomSkinLoader.logger.info("Successfully load Extra List.");
|
||||
if (ssp.type != null) {
|
||||
ProfileLoader.IProfileLoader loader = ProfileLoader.LOADERS.get(ssp.type.toLowerCase());
|
||||
if (loader == null) {
|
||||
CustomSkinLoader.logger.info("Extra List will be ignored: Type '" + ssp.type +
|
||||
"' is not defined.");
|
||||
continue;
|
||||
}
|
||||
boolean duplicate = false;
|
||||
for (SkinSiteProfile ssp0 : this.loadlist) {
|
||||
if (!ssp0.type.equalsIgnoreCase(ssp.type))
|
||||
continue;
|
||||
if (loader.compare(ssp0, ssp)) {
|
||||
duplicate = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (!duplicate) {
|
||||
adds.add(ssp);
|
||||
CustomSkinLoader.logger.info("Successfully apply Extra List.(" + ssp.name + ")");
|
||||
} else {
|
||||
CustomSkinLoader.logger.info("Extra List will be ignored: Duplicate.(" + ssp.name + ")");
|
||||
}
|
||||
file.delete();
|
||||
} else {
|
||||
CustomSkinLoader.logger.info("Extra List is invalid: Type is not defined.(" +
|
||||
file.getName() + ")");
|
||||
createBrokenFile(file);
|
||||
}
|
||||
} catch (Exception e) {
|
||||
CustomSkinLoader.logger.info("Failed to load Extra List.(" + e + ")");
|
||||
createBrokenFile(file);
|
||||
}
|
||||
}
|
||||
if (adds.size() != 0) {
|
||||
adds.addAll(this.loadlist);
|
||||
this.loadlist = adds;
|
||||
}
|
||||
}
|
||||
|
||||
private void updateLoadlist() {
|
||||
PluginLoader.PLUGINS.stream()
|
||||
.map(ICustomSkinLoaderPlugin::getDefaultProfiles)
|
||||
.filter(Objects::nonNull)
|
||||
.flatMap(Collection::stream)
|
||||
.forEach(profile -> this.loadlist.stream()
|
||||
.filter(ssp -> profile.getName().equals(ssp.name))
|
||||
.forEach(profile::updateSkinSiteProfile));
|
||||
}
|
||||
|
||||
private void initLocalFolder() {
|
||||
for (SkinSiteProfile ssp : this.loadlist) {
|
||||
if (ssp.type == null)
|
||||
continue;
|
||||
ProfileLoader.IProfileLoader loader = ProfileLoader.LOADERS.get(ssp.type.toLowerCase());
|
||||
if (loader == null)
|
||||
continue;
|
||||
loader.init(ssp);
|
||||
}
|
||||
}
|
||||
|
||||
private static void createBrokenFile(File file) {
|
||||
try {
|
||||
File brokenFile = new File(file.getParentFile(), file.getName() + ".broken");
|
||||
if (brokenFile.exists()) {
|
||||
brokenFile.delete();
|
||||
}
|
||||
file.renameTo(brokenFile);
|
||||
} catch (Exception e) {
|
||||
CustomSkinLoader.logger.warning("Failed to create broken file. (" + file.getName() + ")");
|
||||
CustomSkinLoader.logger.warning(e);
|
||||
}
|
||||
}
|
||||
|
||||
// The config file does not exist or was broken.
|
||||
private static Config initConfig() {
|
||||
List<ICustomSkinLoaderPlugin.IDefaultProfile> profiles = new ArrayList<>();
|
||||
for (ICustomSkinLoaderPlugin plugin : PluginLoader.PLUGINS) {
|
||||
List<ICustomSkinLoaderPlugin.IDefaultProfile> defaultProfiles = plugin.getDefaultProfiles();
|
||||
if (defaultProfiles != null) {
|
||||
profiles.addAll(defaultProfiles);
|
||||
}
|
||||
}
|
||||
profiles.sort(Comparator.comparingInt(ICustomSkinLoaderPlugin.IDefaultProfile::getPriority));
|
||||
|
||||
List<SkinSiteProfile> loadlist = new ArrayList<>();
|
||||
for (ICustomSkinLoaderPlugin.IDefaultProfile profile : profiles) {
|
||||
SkinSiteProfile ssp = new SkinSiteProfile();
|
||||
ssp.name = profile.getName();
|
||||
profile.updateSkinSiteProfile(ssp);
|
||||
loadlist.add(ssp);
|
||||
}
|
||||
|
||||
Config config = new Config(loadlist);
|
||||
writeConfig(config, false);
|
||||
return config;
|
||||
}
|
||||
|
||||
private static void writeConfig(Config config, boolean update) {
|
||||
String json = CustomSkinLoader.GSON.toJson(config);
|
||||
if (CustomSkinLoader.CONFIG_FILE.exists())
|
||||
CustomSkinLoader.CONFIG_FILE.delete();
|
||||
try {
|
||||
CustomSkinLoader.CONFIG_FILE.createNewFile();
|
||||
FileUtils.write(CustomSkinLoader.CONFIG_FILE, json, "UTF-8");
|
||||
CustomSkinLoader.logger.info("Successfully " + (update ? "update" : "create") + " config.");
|
||||
} catch (Exception e) {
|
||||
CustomSkinLoader.logger.info("Failed to " + (update ? "update" : "create") + " config.(" + e + ")");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
package customskinloader.config;
|
||||
|
||||
import java.lang.reflect.Field;
|
||||
|
||||
public class SkinSiteProfile {
|
||||
//Common
|
||||
public String name;
|
||||
public String type;
|
||||
public String userAgent;
|
||||
|
||||
//Mojang API
|
||||
public String apiRoot;
|
||||
public String sessionRoot;
|
||||
|
||||
//Json API
|
||||
public String root;
|
||||
|
||||
//Legacy
|
||||
public Boolean checkPNG;//Not suitable for local skin
|
||||
public String skin;
|
||||
public String model;
|
||||
public String cape;
|
||||
public String elytra;
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
StringBuilder sb = new StringBuilder("{ ");
|
||||
Field[] fields = SkinSiteProfile.class.getDeclaredFields();
|
||||
boolean first = true;
|
||||
for (Field field : fields) {
|
||||
try {
|
||||
Object value = field.get(this);
|
||||
if (value == null) continue;
|
||||
if (first) {
|
||||
first = false;
|
||||
} else {
|
||||
sb.append(", ");
|
||||
}
|
||||
sb.append("\"").append(field.getName()).append("\": \"").append(value).append("\"");
|
||||
} catch (Exception ignored) { }
|
||||
}
|
||||
return sb.append(" }").toString();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,269 @@
|
||||
package customskinloader.fake;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.util.NoSuchElementException;
|
||||
import java.util.function.BiPredicate;
|
||||
import java.util.function.Predicate;
|
||||
|
||||
import customskinloader.fake.itf.FakeInterfaceManager;
|
||||
import customskinloader.fake.texture.FakeBufferedImage;
|
||||
import customskinloader.fake.texture.FakeImage;
|
||||
import customskinloader.utils.MinecraftUtil;
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.util.ResourceLocation;
|
||||
|
||||
public class FakeCapeBuffer extends FakeSkinBuffer {
|
||||
private static final ResourceLocation TEXTURE_ELYTRA = new ResourceLocation("textures/entity/elytra.png");
|
||||
private static int loadedGlobal = 0;
|
||||
private static FakeImage elytraImage;
|
||||
|
||||
private static FakeImage loadElytra(FakeImage originalImage) {
|
||||
loadedGlobal++;
|
||||
try {
|
||||
InputStream is = FakeInterfaceManager.IResource_getInputStream(FakeInterfaceManager.IResourceManager_getResource(FakeInterfaceManager.Minecraft_getResourceManager(Minecraft.getMinecraft()), TEXTURE_ELYTRA).get());
|
||||
if (is != null) {
|
||||
FakeImage image = originalImage.createImage(is);
|
||||
if (image.getWidth() % 64 != 0 || image.getHeight() % 32 != 0) { // wtf?
|
||||
return elytraImage;
|
||||
}
|
||||
image = resetImageFormat(image, 22, 0, 46, 22);
|
||||
return image;
|
||||
}
|
||||
} catch (IOException | NoSuchElementException ignored) {
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private int loaded = 0;
|
||||
private double ratioX = -1;
|
||||
private double ratioY = -1;
|
||||
private final ResourceLocation location;
|
||||
private String type = null;
|
||||
|
||||
public FakeCapeBuffer(ResourceLocation location) {
|
||||
this.location = location;
|
||||
}
|
||||
|
||||
@Override
|
||||
public FakeImage parseUserSkin(FakeImage image) {
|
||||
if (image == null) return null;
|
||||
if (isOptiFineCape(image)) {
|
||||
//OptiFine cape should be converted to standard cape
|
||||
this.image = convertOptiFineCape(image);
|
||||
//OptiFine cape contains elytra texture
|
||||
//this.type = "elytra";//But its elytra texture doesn't work
|
||||
} else {
|
||||
this.image = image;
|
||||
}
|
||||
|
||||
// When resource packs were changed, the elytra image needs to be reloaded, and here will be entered again
|
||||
// The first cape which find elytra texture is outdated will reload it
|
||||
if (this.loaded == loadedGlobal) {
|
||||
elytraImage = loadElytra(this.image);
|
||||
}
|
||||
this.loaded = loadedGlobal;
|
||||
if (elytraImage != null) {
|
||||
if (this.ratioX < 0)
|
||||
this.ratioX = this.image.getWidth() / 64.0D;
|
||||
if (this.ratioY < 0)
|
||||
this.ratioY = this.image.getHeight() / 32.0D;
|
||||
if (this.type == null)
|
||||
this.type = this.judgeType();
|
||||
|
||||
if ("cape".equals(this.type)) {
|
||||
this.image = resetImageFormat(this.image, 0, 0, 22, 17);
|
||||
this.attachElytra(elytraImage);
|
||||
if (this.image instanceof FakeBufferedImage) { // before 1.12.2
|
||||
this.refreshTexture((FakeBufferedImage) this.image);
|
||||
}
|
||||
}
|
||||
}
|
||||
return this.image;
|
||||
}
|
||||
|
||||
/**
|
||||
* Judge the cape type
|
||||
*
|
||||
* @return "elytra" if the cape contains elytra texture, otherwise "cape"
|
||||
*/
|
||||
@Override
|
||||
public String judgeType() {
|
||||
if (this.image != null && elytraImage != null) {
|
||||
// If all the pixels in ((22, 0), (45, 21)) is same as background, it means the cape doesn't contain elytra
|
||||
Predicate<Integer> predicate = EQU_BG.apply(this.image.getRGBA(this.image.getWidth() - 1, this.image.getHeight() - 1));
|
||||
return withElytraPixels((x, y) -> !predicate.test(this.image.getRGBA(x, y)), "elytra", "cape");
|
||||
}
|
||||
return "cape";
|
||||
}
|
||||
|
||||
private void attachElytra(FakeImage elytraImage) {
|
||||
if (this.image != null) {
|
||||
int capeW = this.image.getWidth(), capeH = this.image.getHeight();
|
||||
int elytraW = elytraImage.getWidth(), elytraH = elytraImage.getHeight();
|
||||
|
||||
// scale cape and elytra to the same size
|
||||
// cape part ((0, 0), (21, 16)) -> (22 * 17)
|
||||
if (capeW < elytraW) {
|
||||
this.image = scaleImage(this.image, true, elytraW / (double) capeW, 1, capeW / 64.0D, capeH / 32.0D, elytraW, capeH, 0, 0, 22, 17);
|
||||
capeW = elytraW;
|
||||
}
|
||||
if (capeH < elytraH) {
|
||||
this.image = scaleImage(this.image, true, 1, elytraH / (double) capeH, capeW / 64.0D, capeH / 32.0D, capeW, elytraH, 0, 0, 22, 17);
|
||||
capeH = elytraH;
|
||||
}
|
||||
// elytra part ((22, 0), (45, 21)) -> (24 * 22)
|
||||
if (elytraW < capeW) {
|
||||
elytraImage = scaleImage(elytraImage, false, capeW / (double) elytraW, 1, elytraW / 64.0D, elytraH / 32.0D, capeW, elytraH, 22, 0, 46, 22);
|
||||
elytraW = capeW;
|
||||
}
|
||||
if (elytraH < capeH) {
|
||||
elytraImage = scaleImage(elytraImage, false, 1, capeH / (double) elytraH, elytraW / 64.0D, elytraH / 32.0D, elytraW, capeH, 22, 0, 46, 22);
|
||||
elytraH = capeH;
|
||||
}
|
||||
this.ratioX = capeW / 64.0D;
|
||||
this.ratioY = capeH / 32.0D;
|
||||
|
||||
// Overwrite pixels from elytra to cape
|
||||
FakeImage finalElytraImage = elytraImage;
|
||||
withElytraPixels((x, y) -> {
|
||||
this.image.setRGBA(x, y, finalElytraImage.getRGBA(x, y));
|
||||
return false;
|
||||
}, null, null);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Traverse every elytra pixel
|
||||
*
|
||||
* @param predicate the predicate with x and y
|
||||
* @param returnValue if the condition flag equals the condition, then return this value
|
||||
* @param defaultReturnValue otherwise return this value
|
||||
*/
|
||||
private <R> R withElytraPixels(BiPredicate<Integer, Integer> predicate, R returnValue, R defaultReturnValue) {
|
||||
int startX = (int) Math.ceil(22 * ratioX), endX = (int) Math.ceil(46 * ratioX);
|
||||
int startY = (int) Math.ceil(0 * ratioY), endY = (int) Math.ceil(22 * ratioY);
|
||||
int excludeX0 = (int) Math.ceil(24 * ratioX), excludeX1 = (int) Math.ceil(44 * ratioX);
|
||||
int excludeY = (int) Math.ceil(2 * ratioY);
|
||||
for (int x = startX; x < endX; ++x) {
|
||||
for (int y = startY; y < endY; ++y) {
|
||||
if (y < excludeY && (x < excludeX0 || x >= excludeX1)) continue;
|
||||
if (predicate.test(x, y)) {
|
||||
return returnValue;
|
||||
}
|
||||
}
|
||||
}
|
||||
return defaultReturnValue;
|
||||
}
|
||||
|
||||
// TextureID won't be regenerated when changing resource packs before 1.12.2
|
||||
private void refreshTexture(FakeBufferedImage image) {
|
||||
Object textureObj = MinecraftUtil.getTextureManager().getTexture(this.location);
|
||||
if (textureObj != null) {
|
||||
// NOTICE: OptiFine modified the upload process of the texture from ThreadDownloadImageData
|
||||
// Therefore, it may not be correct to simply copy the vanilla behavior
|
||||
FakeInterfaceManager.ThreadDownloadImageData_resetNewBufferedImage(textureObj, image.getImage());
|
||||
}
|
||||
}
|
||||
|
||||
// Some cape image doesn't support alpha channel, so reset image format to ARGB
|
||||
private static FakeImage resetImageFormat(FakeImage image, int startX, int startY, int endX, int endY) {
|
||||
if (image != null) {
|
||||
int width = image.getWidth(), height = image.getHeight();
|
||||
image = scaleImage(image, true, 1, 1, width / 64.0D, height / 32.0D, width, height, startX, startY, endX, endY);
|
||||
}
|
||||
return image;
|
||||
}
|
||||
|
||||
/**
|
||||
* Scale image
|
||||
*
|
||||
* @param image the image to scale.
|
||||
* @param closeOldImage whether close old image
|
||||
* @param scaleWidth width enlargement ratio
|
||||
* @param scaleHeight height enlargement ratio
|
||||
* @param ratioX the ratio of 64 of the old image width
|
||||
* @param ratioY the ratio of 32 of the old image height
|
||||
* @param width the width after scaling.
|
||||
* @param height the height after scaling.
|
||||
* @param startX the x where start to copy.
|
||||
* @param startY the y where start to copy.
|
||||
* @param endX the x where end to copy.
|
||||
* @param endY the y where end to copy.
|
||||
* @return the image after scaling.
|
||||
*/
|
||||
private static FakeImage scaleImage(FakeImage image, boolean closeOldImage, double scaleWidth, double scaleHeight, double ratioX, double ratioY, int width, int height, int startX, int startY, int endX, int endY) {
|
||||
FakeImage newImage = image.createImage(width, height);
|
||||
startX = (int) (startX * ratioX);
|
||||
endX = (int) (endX * ratioX);
|
||||
startY = (int) (startY * ratioY);
|
||||
endY = (int) (endY * ratioY);
|
||||
|
||||
int x0 = (int) (startX * scaleWidth), x1 = (int) ((startX + 1) * scaleWidth), dx0 = x1 - x0;
|
||||
for (int x = startX; x < endX; ++x) {
|
||||
int y0 = (int) (startY * scaleHeight), y1 = (int) ((startY + 1) * scaleHeight), dy0 = y1 - y0;
|
||||
for (int y = startY; y < endY; ++y) {
|
||||
int rgba = image.getRGBA(x, y);
|
||||
for (int dx = 0; dx < dx0; dx++) {
|
||||
for (int dy = 0; dy < dy0; dy++) {
|
||||
newImage.setRGBA(x0 + dx, y0 + dy, rgba);
|
||||
}
|
||||
}
|
||||
y0 = y1;
|
||||
y1 = (int) ((y + 2) * scaleHeight);
|
||||
dy0 = y1 - y0;
|
||||
}
|
||||
x0 = x1;
|
||||
x1 = (int) ((x + 2) * scaleWidth);
|
||||
dx0 = x1 - x0;
|
||||
}
|
||||
if (closeOldImage)
|
||||
image.close();
|
||||
return newImage;
|
||||
}
|
||||
|
||||
/**
|
||||
* Judge OptiFine cape.
|
||||
* OptiFine cape is 46*22 or 92*44 pixels.
|
||||
* <a href="https://optifine.net/capes/Notch.png">46*22 example</a>
|
||||
* <a href="https://optifine.net/capes/OptiFineCape.png">92*44 example</a>
|
||||
*
|
||||
* @param image cape image
|
||||
* @return true if is OptiFine cape
|
||||
* @since 14.16
|
||||
*/
|
||||
private static boolean isOptiFineCape(FakeImage image) {
|
||||
int ratio = image.getWidth() / 46;
|
||||
return image.getHeight() == 22 * ratio && image.getWidth() == 46 * ratio;
|
||||
}
|
||||
|
||||
/**
|
||||
* Convert OptiFine cape to standard cape
|
||||
*
|
||||
* @param image OptiFine cape image
|
||||
* @return standard cape image
|
||||
* @since 14.16
|
||||
*/
|
||||
private static FakeImage convertOptiFineCape(FakeImage image) {
|
||||
int ratio = image.getWidth() / 46;
|
||||
FakeImage newImage = image.createImage(64 * ratio, 32 * ratio);
|
||||
copyImageData(image, newImage);
|
||||
return newImage;
|
||||
}
|
||||
|
||||
/**
|
||||
* Copy image data to another image
|
||||
*
|
||||
* @param from from image
|
||||
* @param to to image
|
||||
*/
|
||||
private static void copyImageData(FakeImage from, FakeImage to) {
|
||||
int width = Math.min(from.getWidth(), to.getWidth());
|
||||
int height = Math.min(from.getHeight(), to.getHeight());
|
||||
for (int x = 0; x < width; ++x) {
|
||||
for (int y = 0; y < height; ++y) {
|
||||
to.setRGBA(x, y, from.getRGBA(x, y));
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,99 @@
|
||||
package customskinloader.fake;
|
||||
|
||||
import java.util.Map;
|
||||
import java.util.UUID;
|
||||
|
||||
import com.google.common.collect.Maps;
|
||||
import com.mojang.authlib.GameProfile;
|
||||
import com.mojang.authlib.minecraft.MinecraftProfileTexture;
|
||||
import com.mojang.authlib.minecraft.MinecraftProfileTexture.Type;
|
||||
|
||||
import customskinloader.CustomSkinLoader;
|
||||
import customskinloader.utils.MinecraftUtil;
|
||||
import net.minecraft.client.renderer.ThreadDownloadImageData;
|
||||
import net.minecraft.client.renderer.texture.ITextureObject;
|
||||
import net.minecraft.client.renderer.texture.SimpleTexture;
|
||||
import net.minecraft.client.renderer.texture.TextureManager;
|
||||
import net.minecraft.client.resources.DefaultPlayerSkin;
|
||||
import net.minecraft.client.resources.SkinManager;
|
||||
import net.minecraft.client.resources.SkinManager.SkinAvailableCallback;
|
||||
import net.minecraft.util.ResourceLocation;
|
||||
import net.minecraft.util.StringUtils;
|
||||
|
||||
public class FakeClientPlayer {
|
||||
/**
|
||||
* Invoked from {@link SkinManager#loadSkin(MinecraftProfileTexture, MinecraftProfileTexture.Type, SkinManager.SkinAvailableCallback)}
|
||||
*/
|
||||
public static ThreadDownloadImageData putCache(ThreadDownloadImageData threaddownloadimagedata, SkinManager.SkinAvailableCallback skinAvailableCallback, ResourceLocation resourcelocation) {
|
||||
if (skinAvailableCallback instanceof FakeClientPlayer.LegacyBuffer) {//Cache for client player
|
||||
textureCache.put(resourcelocation, threaddownloadimagedata);
|
||||
}
|
||||
return threaddownloadimagedata;
|
||||
}
|
||||
|
||||
//For Legacy Skin
|
||||
public static ThreadDownloadImageData getDownloadImageSkin(ResourceLocation resourceLocationIn, String username) {
|
||||
//CustomSkinLoader.logger.debug("FakeClientPlayer/getDownloadImageSkin "+username);
|
||||
TextureManager textman = MinecraftUtil.getTextureManager();
|
||||
ITextureObject ito = textman.getTexture(resourceLocationIn);
|
||||
|
||||
if (ito == null || !(ito instanceof ThreadDownloadImageData)) {
|
||||
//if Legacy Skin for username not loaded yet
|
||||
SkinManager skinman = MinecraftUtil.getSkinManager();
|
||||
UUID offlineUUID = getOfflineUUID(username);
|
||||
GameProfile offlineProfile = new GameProfile(offlineUUID, username);
|
||||
|
||||
//Load Default Skin
|
||||
ResourceLocation defaultSkin = DefaultPlayerSkin.getDefaultSkin(offlineUUID);
|
||||
ITextureObject defaultSkinObj = new SimpleTexture(defaultSkin);
|
||||
textman.loadTexture(resourceLocationIn, defaultSkinObj);
|
||||
|
||||
//Load Skin from SkinManager
|
||||
skinman.loadProfileTextures(offlineProfile, new LegacyBuffer(resourceLocationIn), false);
|
||||
}
|
||||
|
||||
if (ito instanceof ThreadDownloadImageData)
|
||||
return (ThreadDownloadImageData) ito;
|
||||
else
|
||||
return null;
|
||||
}
|
||||
|
||||
public static ResourceLocation getLocationSkin(String username) {
|
||||
//CustomSkinLoader.logger.debug("FakeClientPlayer/getLocationSkin "+username);
|
||||
return new ResourceLocation("skins/legacy-" + StringUtils.stripControlCodes(username));
|
||||
}
|
||||
|
||||
public static UUID getOfflineUUID(String username) {
|
||||
return UUID.nameUUIDFromBytes(("OfflinePlayer:" + username).getBytes());
|
||||
}
|
||||
|
||||
public static Map<ResourceLocation, ITextureObject> textureCache = Maps.newHashMap();
|
||||
|
||||
public static class LegacyBuffer implements SkinAvailableCallback {
|
||||
ResourceLocation resourceLocationIn;
|
||||
boolean loaded = false;
|
||||
|
||||
public LegacyBuffer(ResourceLocation resourceLocationIn) {
|
||||
CustomSkinLoader.logger.debug("Loading Legacy Texture (" + resourceLocationIn + ")");
|
||||
this.resourceLocationIn = resourceLocationIn;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void skinAvailable(Type typeIn, ResourceLocation location, MinecraftProfileTexture profileTexture) {
|
||||
if (typeIn != Type.SKIN || loaded)
|
||||
return;
|
||||
|
||||
TextureManager textman = MinecraftUtil.getTextureManager();
|
||||
ITextureObject ito = textman.getTexture(location);
|
||||
if (ito == null)
|
||||
ito = textureCache.get(location);
|
||||
if (ito == null)
|
||||
return;
|
||||
|
||||
loaded = true;
|
||||
textman.loadTexture(resourceLocationIn, ito);
|
||||
CustomSkinLoader.logger.debug("Legacy Texture (" + resourceLocationIn + ") Loaded as " +
|
||||
ito.toString() + " (" + location + ")");
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,40 @@
|
||||
package customskinloader.fake;
|
||||
|
||||
import java.io.File;
|
||||
import java.util.Map;
|
||||
|
||||
import com.mojang.authlib.minecraft.MinecraftProfileTexture;
|
||||
import customskinloader.utils.HttpTextureUtil;
|
||||
import net.minecraft.util.ResourceLocation;
|
||||
|
||||
public class FakeMinecraftProfileTexture extends MinecraftProfileTexture {
|
||||
private HttpTextureUtil.HttpTextureInfo info;
|
||||
private ResourceLocation resourceLocation;
|
||||
|
||||
public FakeMinecraftProfileTexture(String url, Map<String, String> metadata) {
|
||||
super(url, metadata);
|
||||
this.info = HttpTextureUtil.toHttpTextureInfo(url);
|
||||
}
|
||||
|
||||
public void setResourceLocation(ResourceLocation resourceLocation) {
|
||||
this.resourceLocation = resourceLocation;
|
||||
}
|
||||
|
||||
public ResourceLocation getResourceLocation() {
|
||||
return this.resourceLocation;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getUrl() {
|
||||
return this.info.url;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getHash() {
|
||||
return this.info.hash;
|
||||
}
|
||||
|
||||
public File getCacheFile() {
|
||||
return this.info.cacheFile;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,186 @@
|
||||
package customskinloader.fake;
|
||||
|
||||
import java.awt.image.BufferedImage;
|
||||
import java.util.function.Function;
|
||||
import java.util.function.Predicate;
|
||||
|
||||
import customskinloader.CustomSkinLoader;
|
||||
import customskinloader.fake.texture.FakeBufferedImage;
|
||||
import customskinloader.fake.texture.FakeImage;
|
||||
import customskinloader.fake.texture.FakeNativeImage;
|
||||
import net.minecraft.client.renderer.IImageBuffer;
|
||||
import net.minecraft.client.renderer.texture.NativeImage;
|
||||
|
||||
public class FakeSkinBuffer implements IImageBuffer {
|
||||
private int ratio = 1;
|
||||
FakeImage image = null;
|
||||
|
||||
//parseUserSkin for 1.15+
|
||||
public static NativeImage processLegacySkin(NativeImage image, Runnable processTask, Function<NativeImage, NativeImage> processLegacySkin) {
|
||||
if (processTask instanceof IImageBuffer) {
|
||||
return ((IImageBuffer) processTask).func_195786_a(image);
|
||||
}
|
||||
return processLegacySkin.apply(image);
|
||||
}
|
||||
|
||||
//parseUserSkin for 1.13+
|
||||
public NativeImage func_195786_a(NativeImage image) {
|
||||
if (image == null)
|
||||
return null;
|
||||
|
||||
FakeImage img = parseUserSkin(new FakeNativeImage(image));
|
||||
if (img instanceof FakeNativeImage)
|
||||
return ((FakeNativeImage) img).getImage();
|
||||
|
||||
CustomSkinLoader.logger.warning("Failed to parseUserSkin(func_195786_a).");
|
||||
return null;
|
||||
}
|
||||
|
||||
//parseUserSkin for 1.12.2-
|
||||
public BufferedImage parseUserSkin(BufferedImage image) {
|
||||
if (image == null)
|
||||
return null;
|
||||
|
||||
FakeImage img = parseUserSkin(new FakeBufferedImage(image));
|
||||
if (img instanceof FakeBufferedImage)
|
||||
return ((FakeBufferedImage) img).getImage();
|
||||
|
||||
CustomSkinLoader.logger.warning("Failed to parseUserSkin.");
|
||||
return null;
|
||||
}
|
||||
|
||||
public FakeImage parseUserSkin(FakeImage image) {
|
||||
if (image == null) return null;
|
||||
this.ratio = image.getWidth() / 64;
|
||||
|
||||
if (image.getHeight() != image.getWidth()) {//Single Layer
|
||||
//Create a new image and copy origin image data
|
||||
FakeImage img = image.createImage(64 * ratio, 64 * ratio);
|
||||
img.copyImageData(image);
|
||||
image.close();
|
||||
image = img;
|
||||
image.fillArea(0 * ratio, 32 * ratio, 64 * ratio, 32 * ratio);
|
||||
|
||||
//Right Leg -> Left Leg
|
||||
image.copyArea(4 * ratio, 16 * ratio, 16 * ratio, 32 * ratio, 4 * ratio, 4 * ratio, true, false);//Top
|
||||
image.copyArea(8 * ratio, 16 * ratio, 16 * ratio, 32 * ratio, 4 * ratio, 4 * ratio, true, false);//Bottom
|
||||
image.copyArea(0 * ratio, 20 * ratio, 24 * ratio, 32 * ratio, 4 * ratio, 12 * ratio, true, false);//Right
|
||||
image.copyArea(4 * ratio, 20 * ratio, 16 * ratio, 32 * ratio, 4 * ratio, 12 * ratio, true, false);//Front
|
||||
image.copyArea(8 * ratio, 20 * ratio, 8 * ratio, 32 * ratio, 4 * ratio, 12 * ratio, true, false);//Left
|
||||
image.copyArea(12 * ratio, 20 * ratio, 16 * ratio, 32 * ratio, 4 * ratio, 12 * ratio, true, false);//Back
|
||||
//Right Arm -> Left Arm
|
||||
image.copyArea(44 * ratio, 16 * ratio, -8 * ratio, 32 * ratio, 4 * ratio, 4 * ratio, true, false);//Top
|
||||
image.copyArea(48 * ratio, 16 * ratio, -8 * ratio, 32 * ratio, 4 * ratio, 4 * ratio, true, false);//Bottom
|
||||
image.copyArea(40 * ratio, 20 * ratio, 0 * ratio, 32 * ratio, 4 * ratio, 12 * ratio, true, false);//Right
|
||||
image.copyArea(44 * ratio, 20 * ratio, -8 * ratio, 32 * ratio, 4 * ratio, 12 * ratio, true, false);//Front
|
||||
image.copyArea(48 * ratio, 20 * ratio, -16 * ratio, 32 * ratio, 4 * ratio, 12 * ratio, true, false);//Left
|
||||
image.copyArea(52 * ratio, 20 * ratio, -8 * ratio, 32 * ratio, 4 * ratio, 12 * ratio, true, false);//Back
|
||||
}
|
||||
|
||||
this.image = image;
|
||||
setAreaDueToConfig(0 * ratio, 0 * ratio, 32 * ratio, 16 * ratio);//Head - 1
|
||||
setAreaTransparent(32 * ratio, 0 * ratio, 64 * ratio, 16 * ratio);//Head - 2
|
||||
setAreaDueToConfig(16 * ratio, 16 * ratio, 40 * ratio, 32 * ratio);//Body - 1
|
||||
setAreaTransparent(16 * ratio, 32 * ratio, 40 * ratio, 48 * ratio);//Body - 2
|
||||
|
||||
setAreaDueToConfig(40 * ratio, 16 * ratio, 56 * ratio, 32 * ratio);//Right Arm - 1
|
||||
setAreaTransparent(40 * ratio, 32 * ratio, 56 * ratio, 48 * ratio);//Right Arm - 2
|
||||
setAreaDueToConfig(0 * ratio, 16 * ratio, 16 * ratio, 32 * ratio);//Right Leg - 1
|
||||
setAreaTransparent(0 * ratio, 32 * ratio, 16 * ratio, 48 * ratio);//Right Leg - 2
|
||||
|
||||
setAreaDueToConfig(32 * ratio, 48 * ratio, 48 * ratio, 64 * ratio);//Left Arm - 1
|
||||
setAreaTransparent(48 * ratio, 48 * ratio, 64 * ratio, 64 * ratio);//Left Arm - 2
|
||||
setAreaDueToConfig(16 * ratio, 48 * ratio, 32 * ratio, 64 * ratio);//Left Leg - 1
|
||||
setAreaTransparent(0 * ratio, 48 * ratio, 16 * ratio, 64 * ratio);//Left Leg - 2
|
||||
return image;
|
||||
}
|
||||
|
||||
/** Judge if the color is transparent or same with background */
|
||||
static final Function<Integer, Predicate<Integer>> EQU_BG = bgColor -> getA(bgColor) == 0 ? (c) -> getA(c) == 0 : (c) -> c.equals(bgColor);
|
||||
|
||||
/**
|
||||
* Judge the type of skin
|
||||
* Must be called after parseUserSkin
|
||||
*
|
||||
* @return type of skin (slim / default)
|
||||
* @since 14.9
|
||||
*/
|
||||
public String judgeType() {
|
||||
if (this.image == null)
|
||||
return "default";
|
||||
int bgColor = image.getRGBA(63 * ratio, 20 * ratio);
|
||||
/*
|
||||
* If background is transparent, all the pixels in ((54, 20), (55, 31)) areas is transparent,
|
||||
* which means it is Alex model.
|
||||
* If background is opaque, all the pixels in ((54, 20), (55, 31)) areas is same with background,
|
||||
* which means it is Alex model.
|
||||
* Otherwise, it is Steve model.
|
||||
* */
|
||||
Predicate<Integer> predicate = EQU_BG.apply(bgColor);
|
||||
for (int x = 54 * ratio; x <= 55 * ratio; ++x) {
|
||||
for (int y = 20 * ratio; y <= 31 * ratio; ++y) {
|
||||
int color = image.getRGBA(x, y);
|
||||
if (!predicate.test(color)) {
|
||||
return "default";
|
||||
}
|
||||
}
|
||||
}
|
||||
return "slim";
|
||||
}
|
||||
|
||||
/* 2^24-1
|
||||
* 00000000 11111111 11111111 11111111 */
|
||||
private static final int A = 16777215;
|
||||
private static final int WHITE = getARGB(255, 255, 255, 255);
|
||||
private static final int BLACK = getARGB(255, 0, 0, 0);
|
||||
|
||||
private boolean isFilled(int x0, int y0, int x1, int y1) {
|
||||
int data = image.getRGBA(x0, y0);
|
||||
if (data != WHITE && data != BLACK)
|
||||
return false;
|
||||
for (int x = x0; x < x1; ++x)
|
||||
for (int y = y0; y < y1; ++y)
|
||||
if (image.getRGBA(x, y) != data)
|
||||
return false;
|
||||
return true;
|
||||
}
|
||||
|
||||
private void setAreaTransparent(int x0, int y0, int x1, int y1) {
|
||||
if (!isFilled(x0, y0, x1, y1))
|
||||
return;
|
||||
for (int x = x0; x < x1; ++x)
|
||||
for (int y = y0; y < y1; ++y)
|
||||
image.setRGBA(x, y, image.getRGBA(x, y) & A);
|
||||
}
|
||||
|
||||
/* -2^24
|
||||
* 00000001 00000000 00000000 00000000 ->
|
||||
* 11111110 11111111 11111111 11111111 ->
|
||||
* 11111111 00000000 00000000 00000000 */
|
||||
private static final int B = -16777216;
|
||||
|
||||
private void setAreaOpaque(int x0, int y0, int x1, int y1) {
|
||||
for (int x = x0; x < x1; ++x)
|
||||
for (int y = y0; y < y1; ++y)
|
||||
image.setRGBA(x, y, image.getRGBA(x, y) | B);
|
||||
}
|
||||
|
||||
private void setAreaDueToConfig(int x0, int y0, int x1, int y1) {
|
||||
if (customskinloader.CustomSkinLoader.config.enableTransparentSkin)
|
||||
setAreaTransparent(x0, y0, x1, y1);
|
||||
else
|
||||
setAreaOpaque(x0, y0, x1, y1);
|
||||
}
|
||||
|
||||
public void skinAvailable() {
|
||||
//A callback when skin loaded, nothing to do
|
||||
}
|
||||
|
||||
private static int getARGB(int a, int r, int g, int b) {
|
||||
return (a << 24) | (r << 16) | (g << 8) | b;
|
||||
}
|
||||
|
||||
private static int getA(int argb) {
|
||||
return (argb & B) >>> 24;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,180 @@
|
||||
package customskinloader.fake;
|
||||
|
||||
import java.awt.image.BufferedImage;
|
||||
import java.io.File;
|
||||
import java.util.Iterator;
|
||||
import java.util.Map;
|
||||
import java.util.Optional;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
|
||||
import com.google.common.collect.ImmutableList;
|
||||
import com.google.common.collect.Maps;
|
||||
import com.google.common.collect.Multimap;
|
||||
import com.mojang.authlib.GameProfile;
|
||||
import com.mojang.authlib.minecraft.MinecraftProfileTexture;
|
||||
import com.mojang.authlib.minecraft.MinecraftSessionService;
|
||||
import customskinloader.CustomSkinLoader;
|
||||
import customskinloader.utils.HttpTextureUtil;
|
||||
import customskinloader.utils.MinecraftUtil;
|
||||
import net.minecraft.client.renderer.texture.NativeImage;
|
||||
import net.minecraft.client.renderer.IImageBuffer;
|
||||
import net.minecraft.client.renderer.texture.TextureManager;
|
||||
import net.minecraft.client.resources.SkinManager;
|
||||
import net.minecraft.client.resources.SkinManager.SkinAvailableCallback;
|
||||
import net.minecraft.util.ResourceLocation;
|
||||
|
||||
public class FakeSkinManager {
|
||||
private final TextureManager textureManager;
|
||||
|
||||
private final Map<ResourceLocation, MinecraftProfileTexture> modelCache = new ConcurrentHashMap<>();
|
||||
|
||||
public FakeSkinManager(TextureManager textureManagerInstance, File skinCacheDirectory, MinecraftSessionService sessionService) {
|
||||
this.textureManager = textureManagerInstance;
|
||||
HttpTextureUtil.defaultCacheDir = skinCacheDirectory;
|
||||
}
|
||||
|
||||
/**
|
||||
* Invoked from {@link SkinManager#loadSkin(MinecraftProfileTexture, MinecraftProfileTexture.Type, SkinAvailableCallback)}
|
||||
*/
|
||||
public static ResourceLocation setResourceLocation(ResourceLocation resourceLocation, MinecraftProfileTexture profileTexture) {
|
||||
if (profileTexture instanceof FakeMinecraftProfileTexture) {
|
||||
((FakeMinecraftProfileTexture) profileTexture).setResourceLocation(resourceLocation);
|
||||
}
|
||||
return resourceLocation;
|
||||
}
|
||||
|
||||
/**
|
||||
* Invoked from {@link SkinManager#loadSkin(MinecraftProfileTexture, MinecraftProfileTexture.Type, SkinAvailableCallback)}
|
||||
* <p>
|
||||
* {@code skinAvailableCallback.skinAvailable(textureType, resourcelocation, profileTexture);} -> {@code skinAvailableCallback.skinAvailable(textureType, resourcelocation, this.fakeManager.getModelCache(profileTexture, resourcelocation));}
|
||||
* <p>
|
||||
*/
|
||||
public static MinecraftProfileTexture getModelCache(MinecraftProfileTexture profileTexture, FakeSkinManager fakeManager, ResourceLocation location) {
|
||||
return fakeManager.modelCache.getOrDefault(location, profileTexture);
|
||||
}
|
||||
|
||||
/**
|
||||
* Invoked from {@link SkinManager#loadSkin(MinecraftProfileTexture, MinecraftProfileTexture.Type, SkinAvailableCallback)}
|
||||
*/
|
||||
public static Object[] createThreadDownloadImageData(ImmutableList<Object> list, FakeSkinManager fakeManager, MinecraftProfileTexture profileTexture, MinecraftProfileTexture.Type textureType, SkinManager.SkinAvailableCallback skinAvailableCallback) {
|
||||
Object[] params = list.toArray();
|
||||
if (profileTexture instanceof FakeMinecraftProfileTexture && params.length > 1) {
|
||||
FakeMinecraftProfileTexture fakeProfileTexture = (FakeMinecraftProfileTexture) profileTexture;
|
||||
ResourceLocation resourcelocation = fakeProfileTexture.getResourceLocation();
|
||||
if (fakeProfileTexture.getResourceLocation() != null) {
|
||||
params[0] = ((FakeMinecraftProfileTexture) profileTexture).getCacheFile();
|
||||
if (params[params.length - 2] instanceof Boolean) {
|
||||
params[params.length - 2] = true;
|
||||
}
|
||||
params[params.length - 1] = fakeManager.new BaseBuffer(skinAvailableCallback, textureType, resourcelocation, profileTexture);
|
||||
}
|
||||
}
|
||||
return params;
|
||||
}
|
||||
|
||||
|
||||
private final static String KEY = "CustomSkinLoaderInfo";
|
||||
/**
|
||||
* Invoked from {@link SkinManager#loadProfileTextures(GameProfile, SkinAvailableCallback, boolean)}
|
||||
*/
|
||||
@SuppressWarnings({ "rawtypes", "unchecked" })
|
||||
public static void loadProfileTextures(Runnable runnable, GameProfile profile) {
|
||||
CustomSkinLoader.loadProfileTextures(() -> CustomSkinLoader.loadProfileLazily(profile, m -> {
|
||||
// This is a hack.
|
||||
((Multimap) profile.getProperties()).put(KEY, m);
|
||||
runnable.run();
|
||||
}));
|
||||
}
|
||||
|
||||
/**
|
||||
* Invoked from {@link SkinManager#lambda$loadProfileTextures$1(GameProfile, boolean, SkinAvailableCallback)}
|
||||
*/
|
||||
@SuppressWarnings({ "rawtypes", "unchecked" })
|
||||
public static Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> getUserProfile(MinecraftSessionService sessionService, GameProfile profile, boolean requireSecure) {
|
||||
// This is a hack.
|
||||
return (Map<MinecraftProfileTexture.Type, MinecraftProfileTexture>) ((Optional) profile.getProperties().removeAll(KEY).stream().findFirst()).orElse(Maps.newHashMap());
|
||||
}
|
||||
|
||||
/**
|
||||
* Invoked from {@link SkinManager#lambda$null$0(Map, SkinAvailableCallback)}
|
||||
*/
|
||||
public static void loadElytraTexture(SkinManager skinManager, Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> map, SkinManager.SkinAvailableCallback skinAvailableCallback) {
|
||||
for (int i = 2; i < MinecraftProfileTexture.Type.values().length; i++) {
|
||||
MinecraftProfileTexture.Type type = MinecraftProfileTexture.Type.values()[i];
|
||||
if (map.containsKey(type)) {
|
||||
skinManager.loadSkin(map.get(type), type, skinAvailableCallback);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> loadSkinFromCache(GameProfile profile) {
|
||||
Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> map = CustomSkinLoader.loadProfileFromCache(profile);
|
||||
for (Iterator<Map.Entry<MinecraftProfileTexture.Type, MinecraftProfileTexture>> it = map.entrySet().iterator(); it.hasNext(); ) {
|
||||
Map.Entry<MinecraftProfileTexture.Type, MinecraftProfileTexture> entry = it.next();
|
||||
MinecraftProfileTexture texture = entry.getValue();
|
||||
if (shouldJudgeType(texture)) {
|
||||
texture = this.modelCache.get(MinecraftUtil.getSkinManager().loadSkin(texture, entry.getKey()));
|
||||
if (texture == null) { // remove texture if was not loaded before
|
||||
it.remove();
|
||||
} else {
|
||||
map.put(entry.getKey(), texture);
|
||||
}
|
||||
}
|
||||
}
|
||||
return map;
|
||||
}
|
||||
|
||||
private static void makeCallback(SkinManager.SkinAvailableCallback callback, MinecraftProfileTexture.Type type, ResourceLocation location, MinecraftProfileTexture texture) {
|
||||
if (callback != null)
|
||||
callback.skinAvailable(type, location, texture);
|
||||
}
|
||||
|
||||
private static boolean shouldJudgeType(MinecraftProfileTexture texture) {
|
||||
return texture != null && "auto".equals(texture.getMetadata("model"));
|
||||
}
|
||||
|
||||
private class BaseBuffer implements IImageBuffer {
|
||||
private IImageBuffer buffer;
|
||||
|
||||
private SkinManager.SkinAvailableCallback callback;
|
||||
private MinecraftProfileTexture.Type type;
|
||||
private ResourceLocation location;
|
||||
private MinecraftProfileTexture texture;
|
||||
|
||||
public BaseBuffer(SkinManager.SkinAvailableCallback callback, MinecraftProfileTexture.Type type, ResourceLocation location, MinecraftProfileTexture texture) {
|
||||
switch (type) {
|
||||
case SKIN: this.buffer = new FakeSkinBuffer(); break;
|
||||
case CAPE: this.buffer = new FakeCapeBuffer(location); break;
|
||||
}
|
||||
|
||||
this.callback = callback;
|
||||
this.type = type;
|
||||
this.location = location;
|
||||
this.texture = texture;
|
||||
}
|
||||
|
||||
public NativeImage func_195786_a(NativeImage image) {
|
||||
return buffer instanceof FakeSkinBuffer ? ((FakeSkinBuffer) buffer).func_195786_a(image) : image;
|
||||
}
|
||||
|
||||
public BufferedImage parseUserSkin(BufferedImage image) {
|
||||
return buffer instanceof FakeSkinBuffer ? ((FakeSkinBuffer) buffer).parseUserSkin(image) : image;
|
||||
}
|
||||
|
||||
public void skinAvailable() {
|
||||
if (buffer != null) {
|
||||
buffer.skinAvailable();
|
||||
if (shouldJudgeType(texture) && buffer instanceof FakeSkinBuffer) {
|
||||
//Auto judge skin type
|
||||
Map<String, String> metadata = Maps.newHashMap();
|
||||
String type = ((FakeSkinBuffer) buffer).judgeType();
|
||||
metadata.put("model", type);
|
||||
texture = new MinecraftProfileTexture(texture.getUrl(), metadata);
|
||||
FakeSkinManager.this.modelCache.put(location, texture);
|
||||
}
|
||||
}
|
||||
|
||||
FakeSkinManager.makeCallback(callback, type, location, texture);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,29 @@
|
||||
package customskinloader.fake.itf;
|
||||
|
||||
import java.awt.image.BufferedImage;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.util.Optional;
|
||||
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.client.resources.IResource;
|
||||
import net.minecraft.client.resources.IResourceManager;
|
||||
import net.minecraft.util.ResourceLocation;
|
||||
|
||||
public class FakeInterfaceManager {
|
||||
public static InputStream IResource_getInputStream(Object resource) {
|
||||
return ((IFakeIResource.V2) resource).open();
|
||||
}
|
||||
|
||||
public static Optional<IResource> IResourceManager_getResource(Object resourceManager, ResourceLocation location) throws IOException {
|
||||
return ((IFakeIResourceManager) resourceManager).getResource(location);
|
||||
}
|
||||
|
||||
public static IResourceManager Minecraft_getResourceManager(Minecraft minecraft) {
|
||||
return (IResourceManager) ((IFakeMinecraft) minecraft).func_195551_G();
|
||||
}
|
||||
|
||||
public static void ThreadDownloadImageData_resetNewBufferedImage(Object threadDownloadImageData, BufferedImage image) {
|
||||
((IFakeThreadDownloadImageData) threadDownloadImageData).resetNewBufferedImage(image);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,22 @@
|
||||
package customskinloader.fake.itf;
|
||||
|
||||
import java.io.InputStream;
|
||||
|
||||
import net.minecraft.client.resources.IResource;
|
||||
|
||||
/** {@link IResource} is no longer an interface since 22w14a */
|
||||
public interface IFakeIResource {
|
||||
// 1.13.2 ~ 22w13a
|
||||
interface V1 {
|
||||
default InputStream func_199027_b() {
|
||||
return ((IResource) this).getInputStream();
|
||||
}
|
||||
}
|
||||
|
||||
// 22w14a+
|
||||
interface V2 {
|
||||
default InputStream open() {
|
||||
return ((IFakeIResource.V1) this).func_199027_b();
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
package customskinloader.fake.itf;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.util.Optional;
|
||||
|
||||
import net.minecraft.client.resources.IResourceManager;
|
||||
import net.minecraft.resources.IResource;
|
||||
import net.minecraft.util.ResourceLocation;
|
||||
|
||||
public interface IFakeIResourceManager {
|
||||
// 1.13.2 ~ 22w13a
|
||||
default IResource func_199002_a(ResourceLocation location) throws IOException {
|
||||
return (IResource) ((IResourceManager) this).getResource(location);
|
||||
}
|
||||
|
||||
// 22w14a+
|
||||
default Optional getResource(ResourceLocation location) throws IOException {
|
||||
return Optional.ofNullable(this.func_199002_a(location));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,11 @@
|
||||
package customskinloader.fake.itf;
|
||||
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.resources.IResourceManager;
|
||||
|
||||
public interface IFakeMinecraft {
|
||||
// 1.13.2+
|
||||
default IResourceManager func_195551_G() {
|
||||
return (IResourceManager) ((Minecraft) this).getResourceManager();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
package customskinloader.fake.itf;
|
||||
|
||||
import java.awt.image.BufferedImage;
|
||||
|
||||
// This interface is only available before 1.12.2
|
||||
public interface IFakeThreadDownloadImageData {
|
||||
/**
|
||||
* Reset {@link net.minecraft.client.renderer.ThreadDownloadImageData#bufferedImage} and
|
||||
* {@link net.minecraft.client.renderer.ThreadDownloadImageData#textureUploaded} to false to refresh texture.
|
||||
*/
|
||||
void resetNewBufferedImage(BufferedImage image);
|
||||
}
|
||||
@@ -0,0 +1,75 @@
|
||||
package customskinloader.fake.texture;
|
||||
|
||||
import java.awt.Color;
|
||||
import java.awt.Graphics;
|
||||
import java.awt.image.BufferedImage;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import javax.imageio.ImageIO;
|
||||
|
||||
public class FakeBufferedImage implements FakeImage {
|
||||
private BufferedImage image;
|
||||
private Graphics graphics;
|
||||
|
||||
public FakeBufferedImage(int width, int height) {
|
||||
this(new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB));
|
||||
}
|
||||
|
||||
public FakeBufferedImage(BufferedImage image) {
|
||||
this.image = image;
|
||||
graphics = image.getGraphics();
|
||||
}
|
||||
|
||||
public BufferedImage getImage() {
|
||||
graphics.dispose();
|
||||
return image;
|
||||
}
|
||||
|
||||
public FakeImage createImage(int width, int height) {
|
||||
return new FakeBufferedImage(width, height);
|
||||
}
|
||||
|
||||
public FakeImage createImage(InputStream is) throws IOException {
|
||||
return new FakeBufferedImage(ImageIO.read(is));
|
||||
}
|
||||
|
||||
public int getWidth() {
|
||||
return image.getWidth();
|
||||
}
|
||||
|
||||
public int getHeight() {
|
||||
return image.getHeight();
|
||||
}
|
||||
|
||||
public int getRGBA(int x, int y) {
|
||||
return image.getRGB(x, y);
|
||||
}
|
||||
|
||||
public void setRGBA(int x, int y, int rgba) {
|
||||
image.setRGB(x, y, rgba);
|
||||
}
|
||||
|
||||
public void copyImageData(FakeImage image) {
|
||||
if (!(image instanceof FakeBufferedImage)) return;
|
||||
BufferedImage img = ((FakeBufferedImage) image).getImage();
|
||||
graphics.drawImage(img, 0, 0, null);
|
||||
}
|
||||
|
||||
public void fillArea(int x0, int y0, int width, int height) {
|
||||
graphics.setColor(new Color(0, 0, 0, 0));
|
||||
graphics.fillRect(x0, y0, width, height);
|
||||
}
|
||||
|
||||
public void copyArea(int x0, int y0, int dx, int dy, int width, int height, boolean reversex, boolean reversey) {
|
||||
int x1 = x0 + width, x2 = x0 + dx, x3 = x2 + width;
|
||||
int y1 = y0 + height, y2 = y0 + dy, y3 = y2 + height;
|
||||
graphics.drawImage(image,
|
||||
reversex ? x3 : x2, reversey ? y3 : y2,
|
||||
reversex ? x2 : x3, reversey ? y2 : y3,
|
||||
x0, y0, x1, y1, null);
|
||||
}
|
||||
|
||||
public void close() {
|
||||
graphics.dispose();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,26 @@
|
||||
package customskinloader.fake.texture;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
|
||||
public interface FakeImage {
|
||||
FakeImage createImage(int width, int height);
|
||||
|
||||
FakeImage createImage(InputStream is) throws IOException;
|
||||
|
||||
int getWidth();
|
||||
|
||||
int getHeight();
|
||||
|
||||
int getRGBA(int x, int y);
|
||||
|
||||
void setRGBA(int x, int y, int rgba);
|
||||
|
||||
void copyImageData(FakeImage image);
|
||||
|
||||
void fillArea(int x0, int y0, int width, int height);
|
||||
|
||||
void copyArea(int x0, int y0, int dx, int dy, int width, int height, boolean reversex, boolean reversey);
|
||||
|
||||
void close();
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
package customskinloader.fake.texture;
|
||||
|
||||
import java.io.InputStream;
|
||||
|
||||
import net.minecraft.client.renderer.texture.NativeImage;
|
||||
|
||||
public class FakeNativeImage implements FakeImage {
|
||||
private NativeImage image;
|
||||
|
||||
public FakeNativeImage(int width, int height) {
|
||||
this(new NativeImage(width, height, true));
|
||||
}
|
||||
|
||||
public FakeNativeImage(NativeImage image) {
|
||||
this.image = image;
|
||||
}
|
||||
|
||||
public NativeImage getImage() {
|
||||
return image;
|
||||
}
|
||||
|
||||
public FakeImage createImage(int width, int height) {
|
||||
return new FakeNativeImage(width, height);
|
||||
}
|
||||
|
||||
public FakeImage createImage(InputStream is) {
|
||||
return new FakeNativeImage(NativeImage.func_195713_a(is));
|
||||
}
|
||||
|
||||
public int getWidth() {
|
||||
return image.func_195702_a();
|
||||
}
|
||||
|
||||
public int getHeight() {
|
||||
return image.func_195714_b();
|
||||
}
|
||||
|
||||
public int getRGBA(int x, int y) {
|
||||
return image.func_195709_a(x, y);
|
||||
}
|
||||
|
||||
public void setRGBA(int x, int y, int rgba) {
|
||||
image.func_195700_a(x, y, rgba);
|
||||
}
|
||||
|
||||
public void copyImageData(FakeImage image) {
|
||||
if (!(image instanceof FakeNativeImage)) return;
|
||||
this.image.func_195703_a(((FakeNativeImage) image).getImage());
|
||||
}
|
||||
|
||||
public void fillArea(int x0, int y0, int width, int height) {
|
||||
image.func_195715_a(x0, y0, width, height, 0);
|
||||
}
|
||||
|
||||
public void copyArea(int x0, int y0, int dx, int dy, int width, int height, boolean reversex, boolean reversey) {
|
||||
image.func_195699_a(x0, y0, dx, dy, width, height, reversex, reversey);
|
||||
}
|
||||
|
||||
public void close() {
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,166 @@
|
||||
package customskinloader.loader;
|
||||
|
||||
import java.io.File;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.nio.file.Files;
|
||||
import java.util.List;
|
||||
|
||||
import com.mojang.authlib.GameProfile;
|
||||
import customskinloader.CustomSkinLoader;
|
||||
import customskinloader.config.SkinSiteProfile;
|
||||
import customskinloader.plugin.ICustomSkinLoaderPlugin;
|
||||
import customskinloader.profile.UserProfile;
|
||||
import customskinloader.utils.HttpRequestUtil;
|
||||
import customskinloader.utils.HttpUtil0;
|
||||
import org.apache.commons.io.IOUtils;
|
||||
import org.apache.commons.lang3.StringUtils;
|
||||
|
||||
public class JsonAPILoader implements ICustomSkinLoaderPlugin, ProfileLoader.IProfileLoader {
|
||||
|
||||
public interface IJsonAPI {
|
||||
List<IDefaultProfile> getDefaultProfiles(JsonAPILoader loader);
|
||||
|
||||
String toJsonUrl(String root, String username);
|
||||
|
||||
default String getPayload(SkinSiteProfile ssp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
/**
|
||||
* get JSON API payload, which will make a POST request
|
||||
*
|
||||
* @param ssp skin site profile
|
||||
* @param username username
|
||||
* @return JSON payload
|
||||
* @since 14.16
|
||||
*/
|
||||
default String getPayload(SkinSiteProfile ssp, String username) {
|
||||
return getPayload(ssp);
|
||||
}
|
||||
|
||||
UserProfile toUserProfile(String root, String json, boolean local);
|
||||
|
||||
String getName();
|
||||
}
|
||||
|
||||
public static class ErrorProfile {
|
||||
public int errno;
|
||||
public String msg;
|
||||
}
|
||||
|
||||
private final IJsonAPI jsonAPI;
|
||||
|
||||
public JsonAPILoader(IJsonAPI jsonAPI) {
|
||||
this.jsonAPI = jsonAPI;
|
||||
}
|
||||
|
||||
// === ICustomSkinLoaderPlugin ===
|
||||
|
||||
@Override
|
||||
public ProfileLoader.IProfileLoader getProfileLoader() {
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<IDefaultProfile> getDefaultProfiles() {
|
||||
return this.jsonAPI.getDefaultProfiles(this);
|
||||
}
|
||||
|
||||
public abstract static class DefaultProfile implements ICustomSkinLoaderPlugin.IDefaultProfile {
|
||||
protected final JsonAPILoader loader;
|
||||
|
||||
public DefaultProfile(JsonAPILoader loader) {
|
||||
this.loader = loader;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void updateSkinSiteProfile(SkinSiteProfile ssp) {
|
||||
ssp.type = this.loader.getName();
|
||||
ssp.root = this.getRoot();
|
||||
}
|
||||
|
||||
public abstract String getRoot();
|
||||
}
|
||||
|
||||
// === IProfileLoader ===
|
||||
|
||||
@Override
|
||||
public UserProfile loadProfile(SkinSiteProfile ssp, GameProfile gameProfile) throws Exception {
|
||||
String username = gameProfile.getName();
|
||||
if (StringUtils.isEmpty(ssp.root)) {
|
||||
CustomSkinLoader.logger.info("Root not defined.");
|
||||
return null;
|
||||
}
|
||||
boolean local = HttpUtil0.isLocal(ssp.root);
|
||||
String jsonUrl = this.jsonAPI.toJsonUrl(ssp.root, username);
|
||||
//Some API like MinecraftCapesAPI won't load profile at sometime
|
||||
if (jsonUrl == null) {
|
||||
CustomSkinLoader.logger.info("Profile url not found.");
|
||||
return null;
|
||||
}
|
||||
String json;
|
||||
if (local) {
|
||||
File jsonFile = new File(CustomSkinLoader.DATA_DIR, jsonUrl);
|
||||
if (!jsonFile.exists()) {
|
||||
CustomSkinLoader.logger.info("Profile File not found.");
|
||||
return null;
|
||||
}
|
||||
json = IOUtils.toString(Files.newInputStream(jsonFile.toPath()), StandardCharsets.UTF_8);
|
||||
} else {
|
||||
try {
|
||||
HttpRequestUtil.HttpResponce responce = HttpRequestUtil
|
||||
.makeHttpRequest(new HttpRequestUtil.HttpRequest(jsonUrl).setCacheTime(90)
|
||||
.setUserAgent(ssp.userAgent).setPayload(this.jsonAPI.getPayload(ssp, username)));
|
||||
json = responce.content;
|
||||
} catch (ProfileNotFoundException ignored) {
|
||||
CustomSkinLoader.logger.info("Profile not found.");
|
||||
return null;
|
||||
}
|
||||
}
|
||||
if (json == null || json.equals("")) {
|
||||
CustomSkinLoader.logger.info("Profile not found.");
|
||||
return null;
|
||||
}
|
||||
|
||||
ErrorProfile profile = CustomSkinLoader.GSON.fromJson(json, ErrorProfile.class);
|
||||
if (profile.errno != 0) {
|
||||
CustomSkinLoader.logger.info("Error " + profile.errno + ": " + profile.msg);
|
||||
return null;
|
||||
}
|
||||
|
||||
UserProfile p = this.jsonAPI.toUserProfile(ssp.root, json, local);
|
||||
if (p == null || p.isEmpty()) {
|
||||
CustomSkinLoader.logger.info("Both skin and cape not found.");
|
||||
return null;
|
||||
} else {
|
||||
return p;
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean compare(SkinSiteProfile ssp0, SkinSiteProfile ssp1) {
|
||||
return !StringUtils.isNoneEmpty(ssp0.root) || ssp0.root.equalsIgnoreCase(ssp1.root);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getName() {
|
||||
return this.jsonAPI.getName();
|
||||
}
|
||||
|
||||
@Override
|
||||
public void init(SkinSiteProfile ssp) {
|
||||
if (HttpUtil0.isLocal(ssp.root)) {
|
||||
File f = new File(ssp.root);
|
||||
if (!f.exists())
|
||||
//noinspection ResultOfMethodCallIgnored
|
||||
f.mkdirs();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* When getting payload, this exception can end skin loading
|
||||
* @since 14.16
|
||||
*/
|
||||
public static class ProfileNotFoundException extends RuntimeException {
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,236 @@
|
||||
package customskinloader.loader;
|
||||
|
||||
import java.io.File;
|
||||
import java.util.List;
|
||||
import java.util.Objects;
|
||||
import java.util.function.Consumer;
|
||||
|
||||
import com.google.common.collect.Lists;
|
||||
import com.mojang.authlib.GameProfile;
|
||||
import customskinloader.CustomSkinLoader;
|
||||
import customskinloader.config.SkinSiteProfile;
|
||||
import customskinloader.plugin.ICustomSkinLoaderPlugin;
|
||||
import customskinloader.profile.UserProfile;
|
||||
import customskinloader.utils.HttpRequestUtil;
|
||||
import customskinloader.utils.HttpTextureUtil;
|
||||
import customskinloader.utils.HttpUtil0;
|
||||
|
||||
public class LegacyLoader implements ICustomSkinLoaderPlugin, ProfileLoader.IProfileLoader {
|
||||
|
||||
@Override
|
||||
public ProfileLoader.IProfileLoader getProfileLoader() {
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<IDefaultProfile> getDefaultProfiles() {
|
||||
return Lists.newArrayList(new LocalSkin(this),
|
||||
getCapeProfile(this, "OptiFine", "https://optifine.net/capes/{USERNAME}.png", 810),
|
||||
getCapeProfile(this, "CloakPlus", "http://161.35.130.99/capes/{USERNAME}.png", 840),
|
||||
getCapeProfile(this, "LabyMod", "https://dl.labymod.net/capes/{STANDARD_UUID}", 850),
|
||||
getCapeProfile(this, "Cosmetica", "https://api.cosmetica.cc/get/cloak?username={USERNAME}&uuid={STANDARD_UUID}¬hirdparty", 860)
|
||||
);
|
||||
}
|
||||
|
||||
public abstract static class DefaultProfile implements ICustomSkinLoaderPlugin.IDefaultProfile {
|
||||
protected final LegacyLoader loader;
|
||||
|
||||
public DefaultProfile(LegacyLoader loader) {
|
||||
this.loader = loader;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void updateSkinSiteProfile(SkinSiteProfile ssp) {
|
||||
ssp.type = this.loader.getName();
|
||||
if (ssp.checkPNG == null) {
|
||||
ssp.checkPNG = false;
|
||||
}
|
||||
if (ssp.model == null) {
|
||||
ssp.model = "auto";
|
||||
}
|
||||
//Set texture url when it is empty
|
||||
//Remote texture url could be changed, it will be auto updated here
|
||||
if (ssp.skin == null || !HttpUtil0.isLocal(this.getSkinRoot())) {
|
||||
ssp.skin = this.getSkinRoot();
|
||||
}
|
||||
if (ssp.cape == null || !HttpUtil0.isLocal(this.getCapeRoot())) {
|
||||
ssp.cape = this.getCapeRoot();
|
||||
}
|
||||
if (ssp.elytra == null || !HttpUtil0.isLocal(this.getElytraRoot())) {
|
||||
ssp.elytra = this.getElytraRoot();
|
||||
}
|
||||
}
|
||||
|
||||
public abstract String getSkinRoot();
|
||||
|
||||
public abstract String getCapeRoot();
|
||||
|
||||
public abstract String getElytraRoot();
|
||||
}
|
||||
|
||||
public static class LocalSkin extends LegacyLoader.DefaultProfile {
|
||||
public LocalSkin(LegacyLoader loader) {
|
||||
super(loader);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getName() {
|
||||
return "LocalSkin";
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getPriority() {
|
||||
return 710;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getSkinRoot() {
|
||||
return "LocalSkin/skins/{USERNAME}.png";
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getCapeRoot() {
|
||||
return "LocalSkin/capes/{USERNAME}.png";
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getElytraRoot() {
|
||||
return "LocalSkin/elytras/{USERNAME}.png";
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get cape Profile¬
|
||||
*
|
||||
* @since 14.16
|
||||
*/
|
||||
public static LegacyLoader.DefaultProfile getCapeProfile(LegacyLoader loader, String name, String capeRoot, int priority) {
|
||||
return new DefaultProfile(loader) {
|
||||
@Override
|
||||
public String getSkinRoot() {
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getCapeRoot() {
|
||||
return capeRoot;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getElytraRoot() {
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getPriority() {
|
||||
return priority;
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
public static final String USERNAME_PLACEHOLDER = "{USERNAME}";
|
||||
public static final String UUID_PLACEHOLDER = "{UUID}";
|
||||
/**
|
||||
* Mojang UUID with -
|
||||
*
|
||||
* @since 14.16
|
||||
*/
|
||||
public static final String STANDARD_UUID_PLACEHOLDER = "{STANDARD_UUID}";
|
||||
|
||||
@Override
|
||||
public UserProfile loadProfile(SkinSiteProfile ssp, GameProfile gameProfile) {
|
||||
UserProfile profile = new UserProfile();
|
||||
//Try to load all textures
|
||||
getTextureUrl(ssp, gameProfile, ssp.skin, it -> {
|
||||
profile.skinUrl = it;
|
||||
profile.model = ssp.model;
|
||||
});
|
||||
getTextureUrl(ssp, gameProfile, ssp.cape, it -> profile.capeUrl = it);
|
||||
getTextureUrl(ssp, gameProfile, ssp.elytra, it -> profile.elytraUrl = it);
|
||||
|
||||
if (profile.isEmpty()) {
|
||||
CustomSkinLoader.logger.info("No texture could be found.");
|
||||
return null;
|
||||
}
|
||||
return profile;
|
||||
}
|
||||
|
||||
private void getTextureUrl(
|
||||
SkinSiteProfile ssp, GameProfile gameProfile, String baseUrl, Consumer<String> onSuccess) {
|
||||
//Base URL is empty
|
||||
if (baseUrl == null || baseUrl.isEmpty()) {
|
||||
return;
|
||||
}
|
||||
String url = expandURL(baseUrl, gameProfile.getName());
|
||||
//No texture can be loaded
|
||||
if (url == null) {
|
||||
return;
|
||||
}
|
||||
//Local texture file logic
|
||||
if (HttpUtil0.isLocal(url)) {
|
||||
File file = new File(CustomSkinLoader.DATA_DIR, url);
|
||||
if (file.exists() && file.isFile()) {
|
||||
String fakeUrl = HttpTextureUtil.getLocalLegacyFakeUrl(url,
|
||||
HttpTextureUtil.getHash(url, file.length(), file.lastModified()));
|
||||
onSuccess.accept(fakeUrl);
|
||||
}
|
||||
return;
|
||||
}
|
||||
//Remote texture logic
|
||||
HttpRequestUtil.HttpResponce responce = HttpRequestUtil.makeHttpRequest(new HttpRequestUtil.HttpRequest(url)
|
||||
.setUserAgent(ssp.userAgent).setCheckPNG(ssp.checkPNG != null && ssp.checkPNG).setLoadContent(false));
|
||||
if (responce.success) {
|
||||
onSuccess.accept(HttpTextureUtil.getLegacyFakeUrl(url));
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean compare(SkinSiteProfile ssp0, SkinSiteProfile ssp1) {
|
||||
return Objects.equals(ssp0.skin, ssp1.skin) && Objects.equals(ssp0.cape, ssp1.cape) &&
|
||||
Objects.equals(ssp0.elytra, ssp1.elytra);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getName() {
|
||||
return "Legacy";
|
||||
}
|
||||
|
||||
@Override
|
||||
public void init(SkinSiteProfile ssp) {
|
||||
initFolder(ssp.skin);
|
||||
initFolder(ssp.cape);
|
||||
initFolder(ssp.elytra);
|
||||
}
|
||||
|
||||
@SuppressWarnings("ResultOfMethodCallIgnored")
|
||||
private void initFolder(String target) {
|
||||
//Only local skin should init folder
|
||||
if (!HttpUtil0.isLocal(target)) {
|
||||
return;
|
||||
}
|
||||
String file = target.replace(USERNAME_PLACEHOLDER, "init");
|
||||
File folder = new File(CustomSkinLoader.DATA_DIR, file).getParentFile();
|
||||
if (folder != null && !folder.exists()) {
|
||||
folder.mkdirs();
|
||||
}
|
||||
}
|
||||
|
||||
private String expandURL(String url, String username) {
|
||||
String t = url.replace(USERNAME_PLACEHOLDER, username);
|
||||
if (!t.contains(UUID_PLACEHOLDER) && !t.contains(STANDARD_UUID_PLACEHOLDER)) {
|
||||
return t;
|
||||
}
|
||||
String uuid = MojangAPILoader.getMojangUuidByUsername(username, true);
|
||||
//If Mojang uuid not found, won't load the texture
|
||||
if (uuid == null) {
|
||||
return null;
|
||||
}
|
||||
String styledUuid = uuid.replace("-", "");
|
||||
return t.replace(UUID_PLACEHOLDER, styledUuid).replace(STANDARD_UUID_PLACEHOLDER, uuid);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,232 @@
|
||||
package customskinloader.loader;
|
||||
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.util.Collections;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
import java.util.UUID;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
|
||||
import com.google.common.collect.Iterables;
|
||||
import com.google.common.collect.Lists;
|
||||
import com.google.common.collect.Maps;
|
||||
import com.google.gson.Gson;
|
||||
import com.google.gson.GsonBuilder;
|
||||
import com.mojang.authlib.GameProfile;
|
||||
import com.mojang.authlib.minecraft.MinecraftProfileTexture;
|
||||
import com.mojang.authlib.properties.Property;
|
||||
import com.mojang.authlib.properties.PropertyMap;
|
||||
import com.mojang.authlib.yggdrasil.response.MinecraftProfilePropertiesResponse;
|
||||
import com.mojang.authlib.yggdrasil.response.MinecraftTexturesPayload;
|
||||
import com.mojang.util.UUIDTypeAdapter;
|
||||
import customskinloader.CustomSkinLoader;
|
||||
import customskinloader.config.SkinSiteProfile;
|
||||
import customskinloader.plugin.ICustomSkinLoaderPlugin;
|
||||
import customskinloader.profile.ModelManager0;
|
||||
import customskinloader.profile.UserProfile;
|
||||
import customskinloader.utils.HttpRequestUtil;
|
||||
import org.apache.commons.codec.binary.Base64;
|
||||
import org.apache.commons.lang3.StringUtils;
|
||||
|
||||
public class MojangAPILoader implements ICustomSkinLoaderPlugin, ProfileLoader.IProfileLoader {
|
||||
|
||||
@Override
|
||||
public ProfileLoader.IProfileLoader getProfileLoader() {
|
||||
return this;
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<IDefaultProfile> getDefaultProfiles() {
|
||||
return Lists.newArrayList(new Mojang(this));
|
||||
}
|
||||
|
||||
public abstract static class DefaultProfile implements ICustomSkinLoaderPlugin.IDefaultProfile {
|
||||
protected final MojangAPILoader loader;
|
||||
|
||||
public DefaultProfile(MojangAPILoader loader) {
|
||||
this.loader = loader;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void updateSkinSiteProfile(SkinSiteProfile ssp) {
|
||||
ssp.type = this.loader.getName();
|
||||
ssp.apiRoot = this.getAPIRoot();
|
||||
ssp.sessionRoot = this.getSessionRoot();
|
||||
}
|
||||
|
||||
public abstract String getAPIRoot();
|
||||
|
||||
public abstract String getSessionRoot();
|
||||
}
|
||||
|
||||
public static class Mojang extends MojangAPILoader.DefaultProfile {
|
||||
public Mojang(MojangAPILoader loader) {
|
||||
super(loader);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getName() {
|
||||
return "Mojang";
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getPriority() {
|
||||
return 100;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getAPIRoot() {
|
||||
return getMojangApiRoot();
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getSessionRoot() {
|
||||
return getMojangSessionRoot();
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public UserProfile loadProfile(SkinSiteProfile ssp, GameProfile gameProfile) {
|
||||
Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> map = getTextures(gameProfile);
|
||||
if (!map.isEmpty()) {
|
||||
CustomSkinLoader.logger.info("Default profile will be used.");
|
||||
return ModelManager0.toUserProfile(map);
|
||||
}
|
||||
String username = gameProfile.getName();
|
||||
GameProfile newGameProfile = loadGameProfileCached(ssp.apiRoot, username);
|
||||
if (newGameProfile == null) {
|
||||
CustomSkinLoader.logger.info("Profile not found.(" + username + "'s profile not found.)");
|
||||
return null;
|
||||
}
|
||||
newGameProfile = fillGameProfile(ssp.sessionRoot, newGameProfile);
|
||||
map = getTextures(newGameProfile);
|
||||
if (!map.isEmpty()) {
|
||||
gameProfile.getProperties().putAll(newGameProfile.getProperties());
|
||||
return ModelManager0.toUserProfile(map);
|
||||
}
|
||||
CustomSkinLoader.logger.info("Profile not found.(" + username + " doesn't have skin/cape.)");
|
||||
return null;
|
||||
}
|
||||
|
||||
private static final Map<String, GameProfile> gameProfileCache = new ConcurrentHashMap<>();
|
||||
|
||||
public static GameProfile loadGameProfileCached(String apiRoot, String username) {
|
||||
return gameProfileCache.computeIfAbsent(apiRoot + " " + username,
|
||||
ignored -> loadGameProfile(apiRoot, username));
|
||||
}
|
||||
|
||||
//Username -> UUID
|
||||
public static GameProfile loadGameProfile(String apiRoot, String username) {
|
||||
//Doc (https://wiki.vg/Mojang_API#Playernames_-.3E_UUIDs)
|
||||
Gson gson = new GsonBuilder().registerTypeAdapter(UUID.class, new UUIDTypeAdapter()).create();
|
||||
|
||||
HttpRequestUtil.HttpResponce responce = HttpRequestUtil.makeHttpRequest(
|
||||
new HttpRequestUtil.HttpRequest(apiRoot + "profiles/minecraft")
|
||||
.setCacheTime(600).setPayload(gson.toJson(Collections.singletonList(username)))
|
||||
);
|
||||
if (StringUtils.isEmpty(responce.content)) {
|
||||
return null;
|
||||
}
|
||||
|
||||
GameProfile[] profiles = gson.fromJson(responce.content, GameProfile[].class);
|
||||
if (profiles.length == 0) {
|
||||
return null;
|
||||
}
|
||||
GameProfile gameProfile = profiles[0];
|
||||
|
||||
if (gameProfile.getId() == null) {
|
||||
return null;
|
||||
}
|
||||
return new GameProfile(gameProfile.getId(), gameProfile.getName());
|
||||
}
|
||||
|
||||
/**
|
||||
* Get Mojang UUID by username.
|
||||
*
|
||||
* @param username username to query
|
||||
* @param standard if - in UUID
|
||||
* @return UUID in Mojang API style string. Returns {@code null} if username not found in Mojang API.
|
||||
*/
|
||||
public static String getMojangUuidByUsername(String username, boolean standard) {
|
||||
GameProfile profile = loadGameProfileCached(getMojangApiRoot(), username);
|
||||
if (profile == null) {
|
||||
return null;
|
||||
}
|
||||
UUID id = profile.getId();
|
||||
return standard ? id.toString() : UUIDTypeAdapter.fromUUID(id);
|
||||
}
|
||||
|
||||
//UUID -> Profile
|
||||
public static GameProfile fillGameProfile(String sessionRoot, GameProfile profile) {
|
||||
//Doc (http://wiki.vg/Mojang_API#UUID_-.3E_Profile_.2B_Skin.2FCape)
|
||||
HttpRequestUtil.HttpResponce responce = HttpRequestUtil.makeHttpRequest(
|
||||
new HttpRequestUtil.HttpRequest(sessionRoot + "session/minecraft/profile/"
|
||||
+ UUIDTypeAdapter.fromUUID(profile.getId())).setCacheTime(90));
|
||||
if (StringUtils.isEmpty(responce.content)) {
|
||||
return profile;
|
||||
}
|
||||
|
||||
Gson gson = new GsonBuilder()
|
||||
.registerTypeAdapter(UUID.class, new UUIDTypeAdapter())
|
||||
.registerTypeAdapter(PropertyMap.class, new PropertyMap.Serializer())
|
||||
.create();
|
||||
MinecraftProfilePropertiesResponse propertiesResponce = gson.fromJson(responce.content, MinecraftProfilePropertiesResponse.class);
|
||||
GameProfile newGameProfile = new GameProfile(propertiesResponce.getId(), propertiesResponce.getName());
|
||||
newGameProfile.getProperties().putAll(propertiesResponce.getProperties());
|
||||
|
||||
return newGameProfile;
|
||||
}
|
||||
|
||||
public static Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> getTextures(GameProfile gameProfile) {
|
||||
if (gameProfile == null) {
|
||||
return Maps.newHashMap();
|
||||
}
|
||||
Property textureProperty = Iterables.getFirst(gameProfile.getProperties().get("textures"), null);
|
||||
if (textureProperty == null) {
|
||||
return Maps.newHashMap();
|
||||
}
|
||||
String value = textureProperty.getValue();
|
||||
if (StringUtils.isBlank(value)) {
|
||||
return Maps.newHashMap();
|
||||
}
|
||||
String json = new String(Base64.decodeBase64(value), StandardCharsets.UTF_8);
|
||||
Gson gson = new GsonBuilder().registerTypeAdapter(UUID.class, new UUIDTypeAdapter()).create();
|
||||
MinecraftTexturesPayload result = gson.fromJson(json, MinecraftTexturesPayload.class);
|
||||
if (result == null || result.getTextures() == null) {
|
||||
return Maps.newHashMap();
|
||||
}
|
||||
return result.getTextures();
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean compare(SkinSiteProfile ssp0, SkinSiteProfile ssp1) {
|
||||
return (!StringUtils.isNoneEmpty(ssp0.apiRoot) || ssp0.apiRoot.equalsIgnoreCase(ssp1.apiRoot)) ||
|
||||
(!StringUtils.isNoneEmpty(ssp0.sessionRoot) || ssp0.sessionRoot.equalsIgnoreCase(ssp1.sessionRoot));
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getName() {
|
||||
return "MojangAPI";
|
||||
}
|
||||
|
||||
@Override
|
||||
public void init(SkinSiteProfile ssp) {
|
||||
//Init default api & session root for Mojang API
|
||||
if (ssp.apiRoot == null)
|
||||
ssp.apiRoot = getMojangApiRoot();
|
||||
if (ssp.sessionRoot == null)
|
||||
ssp.sessionRoot = getMojangSessionRoot();
|
||||
}
|
||||
|
||||
// Prevent authlib-injector (https://github.com/yushijinhun/authlib-injector) from modifying these strings
|
||||
private static final String MOJANG_API_ROOT = "https://api{DO_NOT_MODIFY}.mojang.com/";
|
||||
private static final String MOJANG_SESSION_ROOT = "https://sessionserver{DO_NOT_MODIFY}.mojang.com/";
|
||||
|
||||
public static String getMojangApiRoot() {
|
||||
return MOJANG_API_ROOT.replace("{DO_NOT_MODIFY}", "");
|
||||
}
|
||||
|
||||
public static String getMojangSessionRoot() {
|
||||
return MOJANG_SESSION_ROOT.replace("{DO_NOT_MODIFY}", "");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
package customskinloader.loader;
|
||||
|
||||
import java.util.HashMap;
|
||||
|
||||
import com.mojang.authlib.GameProfile;
|
||||
import customskinloader.CustomSkinLoader;
|
||||
import customskinloader.config.SkinSiteProfile;
|
||||
import customskinloader.plugin.ICustomSkinLoaderPlugin;
|
||||
import customskinloader.plugin.PluginLoader;
|
||||
import customskinloader.profile.UserProfile;
|
||||
|
||||
public class ProfileLoader {
|
||||
public static final HashMap<String, IProfileLoader> LOADERS = initLoaders();
|
||||
|
||||
private static HashMap<String, IProfileLoader> initLoaders() {
|
||||
HashMap<String, ProfileLoader.IProfileLoader> profileLoaders = new HashMap<>();
|
||||
for (ICustomSkinLoaderPlugin plugin : PluginLoader.PLUGINS) {
|
||||
ProfileLoader.IProfileLoader profileLoader = plugin.getProfileLoader();
|
||||
if (profileLoader != null) {
|
||||
profileLoaders.put(profileLoader.getName().toLowerCase(), profileLoader);
|
||||
CustomSkinLoader.logger.info("Add a profile loader: " + profileLoader.getName());
|
||||
}
|
||||
}
|
||||
return profileLoaders;
|
||||
}
|
||||
|
||||
public interface IProfileLoader {
|
||||
UserProfile loadProfile(SkinSiteProfile ssp,GameProfile gameProfile) throws Exception;
|
||||
boolean compare(SkinSiteProfile ssp0,SkinSiteProfile ssp1);
|
||||
String getName();
|
||||
void init(SkinSiteProfile ssp);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,144 @@
|
||||
package customskinloader.loader.jsonapi;
|
||||
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import com.google.common.collect.Lists;
|
||||
import customskinloader.CustomSkinLoader;
|
||||
import customskinloader.loader.JsonAPILoader;
|
||||
import customskinloader.plugin.ICustomSkinLoaderPlugin;
|
||||
import customskinloader.profile.ModelManager0;
|
||||
import customskinloader.profile.UserProfile;
|
||||
import customskinloader.utils.HttpTextureUtil;
|
||||
import org.apache.commons.lang3.StringUtils;
|
||||
|
||||
public class CustomSkinAPI implements JsonAPILoader.IJsonAPI {
|
||||
|
||||
public static class LittleSkin extends JsonAPILoader.DefaultProfile {
|
||||
public LittleSkin(JsonAPILoader loader) {
|
||||
super(loader);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getName() {
|
||||
return "LittleSkin";
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getPriority() {
|
||||
return 200;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getRoot() {
|
||||
return "https://littleskin.cn/csl/";
|
||||
}
|
||||
}
|
||||
|
||||
public static class BlessingSkin extends JsonAPILoader.DefaultProfile {
|
||||
public BlessingSkin(JsonAPILoader loader) {
|
||||
super(loader);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getName() {
|
||||
return "BlessingSkin";
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getPriority() {
|
||||
return 300;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getRoot() {
|
||||
return "https://skin.prinzeugen.net/";
|
||||
}
|
||||
}
|
||||
|
||||
// // OneSkin has been removed temporarily
|
||||
// public static class OneSkin extends JsonAPILoader.DefaultProfile {
|
||||
// public OneSkin(JsonAPILoader loader) { super(loader); }
|
||||
// @Override public String getName() { return "OneSkin"; }
|
||||
// @Override public int getPriority() { return 500; }
|
||||
// @Override public String getRoot() { return "http://fleey.cn/skin/skin_user/skin_json.php/"; }
|
||||
// }
|
||||
|
||||
private static final String TEXTURES = "textures/";
|
||||
private static final String SUFFIX = ".json";
|
||||
|
||||
@Override
|
||||
public List<ICustomSkinLoaderPlugin.IDefaultProfile> getDefaultProfiles(JsonAPILoader loader) {
|
||||
return Lists.newArrayList(new LittleSkin(loader), new BlessingSkin(loader));
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toJsonUrl(String root, String username) {
|
||||
return root + username + SUFFIX;
|
||||
}
|
||||
|
||||
@Override
|
||||
public UserProfile toUserProfile(String root, String json, boolean local) {
|
||||
CustomSkinAPIProfile profile = CustomSkinLoader.GSON.fromJson(json, CustomSkinAPIProfile.class);
|
||||
UserProfile p = new UserProfile();
|
||||
|
||||
if (StringUtils.isNotBlank(profile.skin)) {
|
||||
p.skinUrl = root + TEXTURES + profile.skin;
|
||||
if (local)
|
||||
p.skinUrl = HttpTextureUtil.getLocalFakeUrl(p.skinUrl);
|
||||
}
|
||||
if (StringUtils.isNotBlank(profile.cape)) {
|
||||
p.capeUrl = root + TEXTURES + profile.cape;
|
||||
if (local)
|
||||
p.capeUrl = HttpTextureUtil.getLocalFakeUrl(p.capeUrl);
|
||||
}
|
||||
if (StringUtils.isNotBlank(profile.elytra)) {
|
||||
p.elytraUrl = root + TEXTURES + profile.elytra;
|
||||
if (local)
|
||||
p.elytraUrl = HttpTextureUtil.getLocalFakeUrl(p.elytraUrl);
|
||||
}
|
||||
|
||||
Map<String, String> textures = new LinkedHashMap<>();
|
||||
if (profile.skins != null)
|
||||
textures.putAll(profile.skins);
|
||||
if (profile.textures != null)
|
||||
textures.putAll(profile.textures);
|
||||
if (textures.isEmpty())
|
||||
return p;
|
||||
|
||||
boolean hasSkin = false;
|
||||
for (String model : textures.keySet()) {
|
||||
ModelManager0.Model enumModel = ModelManager0.getEnumModel(model);
|
||||
if (enumModel == null || StringUtils.isEmpty(textures.get(model)))
|
||||
continue;
|
||||
if (ModelManager0.isSkin(enumModel))
|
||||
if (hasSkin)
|
||||
continue;
|
||||
else
|
||||
hasSkin = true;
|
||||
String url = root + TEXTURES + textures.get(model);
|
||||
if (local)
|
||||
url = HttpTextureUtil.getLocalFakeUrl(url);
|
||||
p.put(enumModel, url);
|
||||
}
|
||||
|
||||
return p;
|
||||
}
|
||||
|
||||
private static class CustomSkinAPIProfile {
|
||||
public String username;
|
||||
public LinkedHashMap<String, String> textures;
|
||||
|
||||
public LinkedHashMap<String, String> skins;
|
||||
|
||||
public String skin;
|
||||
public String cape;
|
||||
public String elytra;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getName() {
|
||||
return "CustomSkinAPI";
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,65 @@
|
||||
package customskinloader.loader.jsonapi;
|
||||
|
||||
import java.io.File;
|
||||
import java.util.List;
|
||||
import java.util.UUID;
|
||||
|
||||
import com.google.common.collect.Lists;
|
||||
import com.google.gson.Gson;
|
||||
import customskinloader.CustomSkinLoader;
|
||||
import customskinloader.config.SkinSiteProfile;
|
||||
import customskinloader.loader.JsonAPILoader;
|
||||
import customskinloader.plugin.ICustomSkinLoaderPlugin;
|
||||
import customskinloader.utils.MinecraftUtil;
|
||||
import org.apache.commons.io.FileUtils;
|
||||
|
||||
public class CustomSkinAPIPlus extends CustomSkinAPI {
|
||||
|
||||
private static String clientID=null;
|
||||
public CustomSkinAPIPlus(){
|
||||
File clientIDFile=new File(CustomSkinLoader.DATA_DIR,"CustomSkinAPIPlus-ClientID");
|
||||
|
||||
if(clientIDFile.isFile())
|
||||
try{
|
||||
clientID=FileUtils.readFileToString(clientIDFile, "UTF-8");
|
||||
}catch(Exception e){
|
||||
e.printStackTrace();
|
||||
}
|
||||
if(clientID==null){
|
||||
clientID=UUID.randomUUID().toString();
|
||||
try {
|
||||
FileUtils.write(clientIDFile, clientID, "UTF-8");
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<ICustomSkinLoaderPlugin.IDefaultProfile> getDefaultProfiles(JsonAPILoader loader) {
|
||||
return Lists.newArrayList();
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getPayload(SkinSiteProfile ssp) {
|
||||
return new Gson().toJson(new CustomSkinAPIPlusPayload());
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getName() {
|
||||
return "CustomSKinAPIPlus";
|
||||
}
|
||||
|
||||
public static class CustomSkinAPIPlusPayload{
|
||||
String gameVersion;//minecraft version
|
||||
String modVersion;//mod version
|
||||
String serverAddress;//ip:port
|
||||
String clientID;//Minecraft Client ID
|
||||
CustomSkinAPIPlusPayload(){
|
||||
gameVersion = MinecraftUtil.getMinecraftMainVersion();
|
||||
modVersion = CustomSkinLoader.CustomSkinLoader_VERSION;
|
||||
serverAddress = MinecraftUtil.isLanServer() ? null : MinecraftUtil.getStandardServerAddress();
|
||||
clientID = CustomSkinAPIPlus.clientID;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,80 @@
|
||||
package customskinloader.loader.jsonapi;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import com.google.common.collect.Lists;
|
||||
import com.google.gson.Gson;
|
||||
import com.google.gson.reflect.TypeToken;
|
||||
import com.mojang.authlib.minecraft.MinecraftProfileTexture;
|
||||
import customskinloader.loader.JsonAPILoader;
|
||||
import customskinloader.plugin.ICustomSkinLoaderPlugin;
|
||||
import customskinloader.profile.ModelManager0;
|
||||
import customskinloader.profile.UserProfile;
|
||||
|
||||
public class ElyByAPI implements JsonAPILoader.IJsonAPI {
|
||||
|
||||
public static class ElyBy extends JsonAPILoader.DefaultProfile {
|
||||
public ElyBy(JsonAPILoader loader) {
|
||||
super(loader);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getName() {
|
||||
return "ElyBy";
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getPriority() {
|
||||
return 400;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getRoot() {
|
||||
return "http://skinsystem.ely.by/textures/";
|
||||
}
|
||||
}
|
||||
|
||||
public static class TLauncher extends JsonAPILoader.DefaultProfile {
|
||||
public TLauncher(JsonAPILoader loader) {
|
||||
super(loader);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getName() {
|
||||
return "TLauncher";
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getPriority() {
|
||||
return 550;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getRoot() {
|
||||
return "https://auth.tlauncher.org/skin/profile/texture/login/";
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<ICustomSkinLoaderPlugin.IDefaultProfile> getDefaultProfiles(JsonAPILoader loader) {
|
||||
return Lists.newArrayList(new ElyBy(loader), new TLauncher(loader));
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toJsonUrl(String root, String username) {
|
||||
return root + username;
|
||||
}
|
||||
|
||||
@Override
|
||||
public UserProfile toUserProfile(String root, String json, boolean local) {
|
||||
Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> result = new Gson().fromJson(json, new TypeToken<Map<MinecraftProfileTexture.Type, MinecraftProfileTexture>>() {
|
||||
}.getType());
|
||||
return ModelManager0.toUserProfile(result);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getName() {
|
||||
return "ElyByAPI";
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,64 @@
|
||||
package customskinloader.loader.jsonapi;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import com.google.common.collect.Lists;
|
||||
import com.google.gson.Gson;
|
||||
import com.mojang.authlib.minecraft.MinecraftProfileTexture;
|
||||
import customskinloader.loader.JsonAPILoader;
|
||||
import customskinloader.plugin.ICustomSkinLoaderPlugin;
|
||||
import customskinloader.profile.ModelManager0;
|
||||
import customskinloader.profile.UserProfile;
|
||||
|
||||
public class GlitchlessAPI implements JsonAPILoader.IJsonAPI {
|
||||
|
||||
public static class GlitchlessGames extends JsonAPILoader.DefaultProfile {
|
||||
public GlitchlessGames(JsonAPILoader loader) {
|
||||
super(loader);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getName() {
|
||||
return "GlitchlessGames";
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getPriority() {
|
||||
return 700;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getRoot() {
|
||||
return "https://games.glitchless.ru/api/minecraft/users/profiles/textures/?nickname=";
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<ICustomSkinLoaderPlugin.IDefaultProfile> getDefaultProfiles(JsonAPILoader loader) {
|
||||
return Lists.newArrayList(new GlitchlessGames(loader));
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toJsonUrl(String root, String username) {
|
||||
return root + username;
|
||||
}
|
||||
|
||||
@Override
|
||||
public UserProfile toUserProfile(String root, String json, boolean local) {
|
||||
GlitchlessApiResponse result = new Gson().fromJson(json, GlitchlessApiResponse.class);
|
||||
if (!result.textures.containsKey(MinecraftProfileTexture.Type.SKIN))
|
||||
return null;
|
||||
|
||||
return ModelManager0.toUserProfile(result.textures);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getName() {
|
||||
return "GlitchlessAPI";
|
||||
}
|
||||
|
||||
public static class GlitchlessApiResponse {
|
||||
protected Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> textures;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,88 @@
|
||||
package customskinloader.loader.jsonapi;
|
||||
|
||||
import com.google.common.collect.Lists;
|
||||
import com.google.gson.Gson;
|
||||
|
||||
import customskinloader.config.SkinSiteProfile;
|
||||
import customskinloader.loader.JsonAPILoader;
|
||||
import customskinloader.loader.MojangAPILoader;
|
||||
import customskinloader.plugin.ICustomSkinLoaderPlugin;
|
||||
import customskinloader.profile.UserProfile;
|
||||
import customskinloader.utils.TextureUtil;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
public class MinecraftCapesAPI implements JsonAPILoader.IJsonAPI {
|
||||
|
||||
public static class MinecraftCapes extends JsonAPILoader.DefaultProfile {
|
||||
public MinecraftCapes(JsonAPILoader loader) {
|
||||
super(loader);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getName() {
|
||||
return "MinecraftCapes";
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getPriority() {
|
||||
return 800;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getRoot() {
|
||||
return "https://minecraftcapes.net/profile/";
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<ICustomSkinLoaderPlugin.IDefaultProfile> getDefaultProfiles(JsonAPILoader loader) {
|
||||
return Lists.newArrayList(new MinecraftCapes(loader));
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toJsonUrl(String root, String username) {
|
||||
String uuid = MojangAPILoader.getMojangUuidByUsername(username, false);
|
||||
//If uuid cannot be found, we won't load profile in this API.
|
||||
if (uuid == null) {
|
||||
return null;
|
||||
}
|
||||
//API url is `${root}${uuid}`
|
||||
return root + uuid;
|
||||
}
|
||||
|
||||
@Override
|
||||
public UserProfile toUserProfile(String root, String json, boolean local) {
|
||||
MinecraftCapesApiResponse result = new Gson().fromJson(json, MinecraftCapesApiResponse.class);
|
||||
if (result.textures == null || result.textures.cape == null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
UserProfile profile = new UserProfile();
|
||||
profile.capeUrl = TextureUtil.parseBase64Texture(result.textures.cape);
|
||||
|
||||
return profile;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getPayload(SkinSiteProfile ssp) {
|
||||
return null;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getName() {
|
||||
return "MinecraftCapesAPI";
|
||||
}
|
||||
|
||||
public static class MinecraftCapesApiResponse {
|
||||
public boolean animatedCape;
|
||||
public boolean capeGlint;
|
||||
public boolean upsideDown;
|
||||
public MinecraftCapesApiTexture textures;
|
||||
|
||||
public static class MinecraftCapesApiTexture {
|
||||
public String cape;
|
||||
public String ears;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,105 @@
|
||||
package customskinloader.loader.jsonapi;
|
||||
|
||||
import java.util.List;
|
||||
import java.util.Map;
|
||||
|
||||
import com.google.common.collect.Lists;
|
||||
import customskinloader.CustomSkinLoader;
|
||||
import customskinloader.loader.JsonAPILoader;
|
||||
import customskinloader.plugin.ICustomSkinLoaderPlugin;
|
||||
import customskinloader.profile.ModelManager0;
|
||||
import customskinloader.profile.UserProfile;
|
||||
import customskinloader.utils.HttpTextureUtil;
|
||||
import org.apache.commons.lang3.StringUtils;
|
||||
|
||||
public class UniSkinAPI implements JsonAPILoader.IJsonAPI {
|
||||
|
||||
public static class SkinMe extends JsonAPILoader.DefaultProfile {
|
||||
public SkinMe(JsonAPILoader loader) {
|
||||
super(loader);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getName() {
|
||||
return "SkinMe";
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getPriority() {
|
||||
return 500;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getRoot() {
|
||||
return "http://www.skinme.cc/uniskin/";
|
||||
}
|
||||
}
|
||||
|
||||
private static final String TEXTURES = "textures/";
|
||||
private static final String SUFFIX = ".json";
|
||||
|
||||
@Override
|
||||
public List<ICustomSkinLoaderPlugin.IDefaultProfile> getDefaultProfiles(JsonAPILoader loader) {
|
||||
return Lists.newArrayList(new SkinMe(loader));
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toJsonUrl(String root, String username) {
|
||||
return root + username + SUFFIX;
|
||||
}
|
||||
|
||||
@Override
|
||||
public UserProfile toUserProfile(String root, String json, boolean local) {
|
||||
UniSkinAPIProfile profile = CustomSkinLoader.GSON.fromJson(json, UniSkinAPIProfile.class);
|
||||
UserProfile p = new UserProfile();
|
||||
|
||||
if (StringUtils.isNotBlank(profile.cape)) {
|
||||
p.capeUrl = root + TEXTURES + profile.cape;
|
||||
if (local)
|
||||
p.capeUrl = HttpTextureUtil.getLocalFakeUrl(p.capeUrl);
|
||||
}
|
||||
|
||||
if (profile.skins == null || profile.skins.isEmpty())
|
||||
return p;
|
||||
if (profile.model_preference == null || profile.model_preference.isEmpty())
|
||||
return p;
|
||||
|
||||
boolean hasSkin = false;
|
||||
for (String model : profile.model_preference) {
|
||||
ModelManager0.Model enumModel = ModelManager0.getEnumModel(model);
|
||||
if (enumModel == null || StringUtils.isEmpty(profile.skins.get(model)))
|
||||
continue;
|
||||
if (ModelManager0.isSkin(enumModel))
|
||||
if (hasSkin)
|
||||
continue;
|
||||
else
|
||||
hasSkin = true;
|
||||
String url = root + TEXTURES + profile.skins.get(model);
|
||||
if (local)
|
||||
url = HttpTextureUtil.getLocalFakeUrl(url);
|
||||
p.put(enumModel, url);
|
||||
}
|
||||
|
||||
return p;
|
||||
}
|
||||
|
||||
/**
|
||||
* Json profile for UniSkinAPI
|
||||
* <a href="https://github.com/RecursiveG/UniSkinMod/blob/master/src/main/java/org/devinprogress/uniskinmod/UniSkinApiProfile.java#L18-L22">Source Code</a>
|
||||
*
|
||||
* @author RecursiveG
|
||||
*/
|
||||
private static class UniSkinAPIProfile {
|
||||
public String player_name;
|
||||
public long last_update;
|
||||
public List<String> model_preference;
|
||||
public Map<String, String> skins;
|
||||
|
||||
public String cape;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getName() {
|
||||
return "UniSkinAPI";
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,110 @@
|
||||
package customskinloader.loader.jsonapi;
|
||||
|
||||
import com.google.common.collect.Lists;
|
||||
import com.google.gson.Gson;
|
||||
import customskinloader.CustomSkinLoader;
|
||||
import customskinloader.config.SkinSiteProfile;
|
||||
import customskinloader.loader.JsonAPILoader;
|
||||
import customskinloader.loader.MojangAPILoader;
|
||||
import customskinloader.plugin.ICustomSkinLoaderPlugin;
|
||||
import customskinloader.profile.UserProfile;
|
||||
import customskinloader.utils.TextureUtil;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
/**
|
||||
* Wynntils cape API
|
||||
* <a href="https://wynntils.com/">Home</a>
|
||||
* Test player: Cael
|
||||
*
|
||||
* @since 14.16
|
||||
*/
|
||||
public class WynntilsAPI implements JsonAPILoader.IJsonAPI {
|
||||
|
||||
public static class Wynntils extends JsonAPILoader.DefaultProfile {
|
||||
public Wynntils(JsonAPILoader loader) {
|
||||
super(loader);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getName() {
|
||||
return "Wynntils";
|
||||
}
|
||||
|
||||
@Override
|
||||
public int getPriority() {
|
||||
return 820;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getRoot() {
|
||||
return "https://athena.wynntils.com/user/getInfo";
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public List<ICustomSkinLoaderPlugin.IDefaultProfile> getDefaultProfiles(JsonAPILoader loader) {
|
||||
return Lists.newArrayList(new Wynntils(loader));
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toJsonUrl(String root, String username) {
|
||||
return root;
|
||||
}
|
||||
|
||||
@Override
|
||||
public UserProfile toUserProfile(String root, String json, boolean local) {
|
||||
WynntilsApiResponse result = new Gson().fromJson(json, WynntilsApiResponse.class);
|
||||
if (result.user == null || result.user.cosmetics == null || result.user.cosmetics.texture == null) {
|
||||
return null;
|
||||
}
|
||||
|
||||
UserProfile profile = new UserProfile();
|
||||
String fakeUrl = TextureUtil.parseBase64Texture(result.user.cosmetics.texture);
|
||||
if (result.user.cosmetics.hasCape) {
|
||||
profile.capeUrl = fakeUrl;
|
||||
} else if (result.user.cosmetics.hasElytra) {
|
||||
profile.elytraUrl = fakeUrl;
|
||||
} else {
|
||||
CustomSkinLoader.logger.warning("Illegal response found in Wynntils");
|
||||
return null;
|
||||
}
|
||||
|
||||
return profile;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getPayload(SkinSiteProfile ssp, String username) {
|
||||
WynntilsApiRequest req = new WynntilsApiRequest();
|
||||
req.uuid = MojangAPILoader.getMojangUuidByUsername(username, true);
|
||||
if (req.uuid == null) {
|
||||
throw new JsonAPILoader.ProfileNotFoundException();
|
||||
}
|
||||
return new Gson().toJson(req);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String getName() {
|
||||
return "WynntilsAPI";
|
||||
}
|
||||
|
||||
public static class WynntilsApiRequest {
|
||||
public String uuid;
|
||||
}
|
||||
|
||||
public static class WynntilsApiResponse {
|
||||
public User user;
|
||||
|
||||
public static class User {
|
||||
public String accountType;
|
||||
public Cosmetics cosmetics;
|
||||
|
||||
public static class Cosmetics {
|
||||
public boolean hasCape;
|
||||
public boolean hasElytra;
|
||||
public boolean hasEars;
|
||||
public String texture;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,44 @@
|
||||
package customskinloader.log;
|
||||
|
||||
import java.io.Writer;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.nio.file.Files;
|
||||
import java.nio.file.Path;
|
||||
import java.nio.file.StandardOpenOption;
|
||||
import java.util.Map;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
|
||||
/**
|
||||
* @since 14.16
|
||||
*/
|
||||
public class LogManager {
|
||||
private static Path logFile;
|
||||
private static Writer logWriter;
|
||||
private static final Map<String, Logger> loggers = new ConcurrentHashMap<>();
|
||||
|
||||
public static void setLogFile(Path logFile) {
|
||||
//Not updated
|
||||
if (logFile == null || logFile.equals(LogManager.logFile)) {
|
||||
return;
|
||||
}
|
||||
LogManager.logFile = logFile;
|
||||
try {
|
||||
//Close previous writer
|
||||
if (logWriter != null) {
|
||||
logWriter.close();
|
||||
}
|
||||
//Set new writer
|
||||
Files.createDirectories(logFile.getParent());
|
||||
logWriter = Files.newBufferedWriter(logFile, StandardCharsets.UTF_8, StandardOpenOption.CREATE);
|
||||
loggers.forEach((k, v) -> v.setWriter(logWriter));
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
public static Logger getLogger(String loggerName) {
|
||||
return loggers.computeIfAbsent(loggerName,
|
||||
it -> new Logger(logWriter, "CustomSkinLoader " + loggerName));
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,185 @@
|
||||
package customskinloader.log;
|
||||
|
||||
import javax.annotation.Nullable;
|
||||
import java.io.*;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.nio.file.Files;
|
||||
import java.text.SimpleDateFormat;
|
||||
import java.util.Date;
|
||||
|
||||
/**
|
||||
* the Logger
|
||||
* Moved from <code>customskinloader.Logger</code>
|
||||
*
|
||||
* @since 14.16
|
||||
*/
|
||||
@SuppressWarnings("ResultOfMethodCallIgnored")
|
||||
public class Logger {
|
||||
private static final SimpleDateFormat DATE_FORMAT = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
|
||||
|
||||
/**
|
||||
* A copy of <code>Config.enableLogStdOut</code>.
|
||||
* Because <code>Config.loadConfig0()</code> will use <code>Logger.log()</code>,
|
||||
* which means cannot access <code>CustomSkinLoader.config</code> here.
|
||||
*
|
||||
* @see customskinloader.config.Config#enableLogStdOut
|
||||
* @since 14.15
|
||||
*/
|
||||
public boolean enableLogStdOut = false;
|
||||
|
||||
public enum Level {
|
||||
DEBUG("DEBUG", false),
|
||||
INFO("INFO", true),
|
||||
WARNING("WARNING", true);
|
||||
|
||||
|
||||
final String name;
|
||||
final boolean display;
|
||||
|
||||
Level(String name, boolean display) {
|
||||
this.name = name;
|
||||
this.display = display;
|
||||
}
|
||||
|
||||
public String getName() {
|
||||
return name;
|
||||
}
|
||||
|
||||
public boolean display() {
|
||||
return display;
|
||||
}
|
||||
}
|
||||
|
||||
private Writer writer = null;
|
||||
|
||||
public void setWriter(Writer writer) {
|
||||
this.writer = writer;
|
||||
}
|
||||
|
||||
public Logger() {
|
||||
//Logger isn't created.
|
||||
}
|
||||
|
||||
public Logger(String logFile) {
|
||||
this(new File(logFile));
|
||||
}
|
||||
|
||||
public Logger(File logFile) {
|
||||
this(logFile, "Unknown");
|
||||
}
|
||||
|
||||
/**
|
||||
* Create Logger with File
|
||||
*
|
||||
* @since 14.16
|
||||
*/
|
||||
public Logger(File logFile, String loggerName) {
|
||||
this.loggerName = loggerName;
|
||||
try {
|
||||
if (!logFile.getParentFile().exists()) {
|
||||
logFile.getParentFile().mkdirs();
|
||||
}
|
||||
if (!logFile.exists()) {
|
||||
logFile.createNewFile();
|
||||
}
|
||||
|
||||
writer = new BufferedWriter(new OutputStreamWriter(
|
||||
Files.newOutputStream(logFile.toPath()), StandardCharsets.UTF_8));
|
||||
|
||||
System.out.println("Log Path: " + logFile.getAbsolutePath());
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Create Logger with special Writer
|
||||
*
|
||||
* @since 14.16
|
||||
*/
|
||||
public Logger(@Nullable Writer writer, String loggerName) {
|
||||
this.loggerName = loggerName;
|
||||
this.writer = writer;
|
||||
}
|
||||
|
||||
/**
|
||||
* Logger name in log
|
||||
*
|
||||
* @since 14.16
|
||||
*/
|
||||
String loggerName;
|
||||
|
||||
public void close() {
|
||||
if (writer != null) {
|
||||
try {
|
||||
writer.close();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Judge if a level can be printed to standard output(System.out) with config.
|
||||
*
|
||||
* @param level log level
|
||||
* @return true - print
|
||||
*/
|
||||
private boolean canPrintToStdOut(Level level) {
|
||||
return level.display() && enableLogStdOut;
|
||||
}
|
||||
|
||||
public void log(Level level, String msg) {
|
||||
//When it neither be printed to standard output nor write to file
|
||||
if (!canPrintToStdOut(level) && writer == null) {
|
||||
return;
|
||||
}
|
||||
|
||||
//Format, print and write
|
||||
String sb = String.format("[%s] [%s/%s] [%s]: %s",
|
||||
DATE_FORMAT.format(new Date()), Thread.currentThread().getName(), level.getName(), loggerName, msg);
|
||||
if (canPrintToStdOut(level)) {
|
||||
System.out.println(sb);
|
||||
}
|
||||
if (writer == null) {
|
||||
return;
|
||||
}
|
||||
try {
|
||||
String sb2 = String.format("%s\r\n", sb);
|
||||
writer.write(sb2);//Writer.write has lock
|
||||
writer.flush();
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
public void debug(String msg) {
|
||||
log(Level.DEBUG, msg);
|
||||
}
|
||||
|
||||
public void debug(String format, Object... objs) {
|
||||
debug(String.format(format, objs));
|
||||
}
|
||||
|
||||
public void info(String msg) {
|
||||
log(Level.INFO, msg);
|
||||
}
|
||||
|
||||
public void info(String format, Object... objs) {
|
||||
info(String.format(format, objs));
|
||||
}
|
||||
|
||||
public void warning(String msg) {
|
||||
log(Level.WARNING, msg);
|
||||
}
|
||||
|
||||
public void warning(String format, Object... objs) {
|
||||
warning(String.format(format, objs));
|
||||
}
|
||||
|
||||
public void warning(Throwable e) {
|
||||
StringWriter sw = new StringWriter();
|
||||
e.printStackTrace(new PrintWriter(sw));
|
||||
log(Level.WARNING, "Exception: " + sw);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,35 @@
|
||||
package customskinloader.plugin;
|
||||
|
||||
import java.util.List;
|
||||
|
||||
import customskinloader.config.SkinSiteProfile;
|
||||
import customskinloader.loader.ProfileLoader;
|
||||
|
||||
public interface ICustomSkinLoaderPlugin {
|
||||
/**
|
||||
* @return return a non-null value if need to add a new profile loader, otherwise return null.
|
||||
*/
|
||||
ProfileLoader.IProfileLoader getProfileLoader();
|
||||
|
||||
/**
|
||||
* @return the default implementations which import by {@link ICustomSkinLoaderPlugin#getProfileLoader()}.
|
||||
*/
|
||||
List<IDefaultProfile> getDefaultProfiles();
|
||||
|
||||
interface IDefaultProfile {
|
||||
/**
|
||||
* @return the name of {@link SkinSiteProfile#name}.
|
||||
*/
|
||||
String getName();
|
||||
|
||||
/**
|
||||
* @return the lower the number, the first to load.
|
||||
*/
|
||||
int getPriority();
|
||||
|
||||
/**
|
||||
* Complete the {@link SkinSiteProfile} from config and write to config.
|
||||
*/
|
||||
void updateSkinSiteProfile(SkinSiteProfile ssp);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
package customskinloader.plugin;
|
||||
|
||||
import java.io.File;
|
||||
import java.net.MalformedURLException;
|
||||
import java.net.URL;
|
||||
import java.net.URLClassLoader;
|
||||
import java.util.ArrayList;
|
||||
import java.util.ServiceLoader;
|
||||
|
||||
import com.google.common.collect.Lists;
|
||||
import customskinloader.CustomSkinLoader;
|
||||
import customskinloader.loader.JsonAPILoader;
|
||||
import customskinloader.loader.LegacyLoader;
|
||||
import customskinloader.loader.MojangAPILoader;
|
||||
import customskinloader.loader.jsonapi.*;
|
||||
import org.apache.commons.io.FileUtils;
|
||||
|
||||
public class PluginLoader {
|
||||
public static final ICustomSkinLoaderPlugin[] DEFAULT_PLUGINS = new ICustomSkinLoaderPlugin[]{
|
||||
new MojangAPILoader(),
|
||||
new LegacyLoader(),
|
||||
new JsonAPILoader(new CustomSkinAPI()),
|
||||
new JsonAPILoader(new CustomSkinAPIPlus()),
|
||||
new JsonAPILoader(new UniSkinAPI()),
|
||||
new JsonAPILoader(new ElyByAPI()),
|
||||
new JsonAPILoader(new GlitchlessAPI()),
|
||||
new JsonAPILoader(new MinecraftCapesAPI()),
|
||||
new JsonAPILoader(new WynntilsAPI()),
|
||||
};
|
||||
public static final ArrayList<ICustomSkinLoaderPlugin> PLUGINS = loadPlugins();
|
||||
|
||||
private static ArrayList<ICustomSkinLoaderPlugin> loadPlugins() {
|
||||
File pluginsDir = new File(CustomSkinLoader.DATA_DIR, "Plugins");
|
||||
ArrayList<URL> urls = new ArrayList<>();
|
||||
if (!pluginsDir.isDirectory()) {
|
||||
//noinspection ResultOfMethodCallIgnored
|
||||
pluginsDir.mkdirs();
|
||||
} else {
|
||||
for (File plugin : FileUtils.listFiles(pluginsDir, new String[]{"jar", "zip"}, false)) {
|
||||
try {
|
||||
urls.add(plugin.toURI().toURL());
|
||||
CustomSkinLoader.logger.info("Found a jar or zip file: " + plugin.getName());
|
||||
} catch (MalformedURLException ignored) {
|
||||
}
|
||||
}
|
||||
}
|
||||
ArrayList<ICustomSkinLoaderPlugin> plugins = Lists.newArrayList(DEFAULT_PLUGINS);
|
||||
|
||||
ServiceLoader<ICustomSkinLoaderPlugin> sl = ServiceLoader.load(ICustomSkinLoaderPlugin.class, new URLClassLoader(urls.toArray(new URL[0]), PluginLoader.class.getClassLoader()));
|
||||
for (ICustomSkinLoaderPlugin plugin : sl) {
|
||||
plugins.add(plugin);
|
||||
}
|
||||
return plugins;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,160 @@
|
||||
package customskinloader.profile;
|
||||
|
||||
import java.io.File;
|
||||
import java.util.*;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
|
||||
import com.google.common.collect.Lists;
|
||||
import org.apache.commons.codec.Charsets;
|
||||
import org.apache.commons.codec.binary.Base64;
|
||||
import org.apache.commons.io.FileUtils;
|
||||
import org.apache.commons.io.FilenameUtils;
|
||||
import org.apache.commons.lang3.StringUtils;
|
||||
|
||||
import com.google.common.collect.Iterables;
|
||||
import com.google.common.collect.Maps;
|
||||
import com.google.gson.Gson;
|
||||
import com.google.gson.GsonBuilder;
|
||||
import com.mojang.authlib.GameProfile;
|
||||
import com.mojang.authlib.minecraft.MinecraftProfileTexture;
|
||||
import com.mojang.authlib.minecraft.MinecraftProfileTexture.Type;
|
||||
import com.mojang.authlib.properties.Property;
|
||||
import com.mojang.util.UUIDTypeAdapter;
|
||||
|
||||
import customskinloader.CustomSkinLoader;
|
||||
import customskinloader.utils.HttpRequestUtil;
|
||||
import customskinloader.utils.HttpRequestUtil.HttpRequest;
|
||||
import customskinloader.utils.HttpRequestUtil.HttpResponce;
|
||||
import customskinloader.utils.HttpTextureUtil;
|
||||
import customskinloader.utils.HttpUtil0;
|
||||
|
||||
public class DynamicSkullManager {
|
||||
public static class SkullTexture{
|
||||
public Map<Type,MinecraftProfileTexture> textures;
|
||||
public String index;//Index File
|
||||
public ArrayList<String> skins;
|
||||
public int interval;
|
||||
public boolean fromZero;
|
||||
//For program
|
||||
public long startTime;
|
||||
public int period;
|
||||
}
|
||||
private Map<GameProfile, SkullTexture> dynamicTextures = new ConcurrentHashMap<>();
|
||||
private Map<GameProfile, Map<Type, MinecraftProfileTexture>> staticTextures = new ConcurrentHashMap<>();
|
||||
private List<GameProfile> loadingList=new ArrayList<GameProfile>();
|
||||
|
||||
private void parseGameProfile(GameProfile profile){
|
||||
Property textureProperty = Iterables.getFirst(profile.getProperties().get("textures"), null);
|
||||
if (textureProperty==null){
|
||||
staticTextures.put(profile, Maps.<Type, MinecraftProfileTexture>newHashMap());
|
||||
return;
|
||||
}
|
||||
String value=textureProperty.getValue();
|
||||
if(StringUtils.isBlank(value)){
|
||||
staticTextures.put(profile, Maps.<Type, MinecraftProfileTexture>newHashMap());
|
||||
return;
|
||||
}
|
||||
@SuppressWarnings("deprecation") String json = new String(Base64.decodeBase64(value), Charsets.UTF_8);
|
||||
Gson gson=new GsonBuilder().registerTypeAdapter(UUID.class,new UUIDTypeAdapter()).create();
|
||||
SkullTexture result=gson.fromJson(json,SkullTexture.class);
|
||||
if(result==null){
|
||||
staticTextures.put(profile, Maps.<Type, MinecraftProfileTexture>newHashMap());
|
||||
return;
|
||||
}
|
||||
staticTextures.put(profile, (result.textures==null || !result.textures.containsKey(Type.SKIN)) ?
|
||||
Maps.<Type, MinecraftProfileTexture>newHashMap() : parseTextures(result.textures));
|
||||
|
||||
if(StringUtils.isNotEmpty(result.index)){
|
||||
File indexFile=new File(CustomSkinLoader.DATA_DIR,result.index);
|
||||
try{
|
||||
String index=FileUtils.readFileToString(indexFile, "UTF-8");
|
||||
if(StringUtils.isNotEmpty(index)){
|
||||
String[] skins = CustomSkinLoader.GSON.fromJson(index, String[].class);
|
||||
if(skins != null && skins.length != 0)
|
||||
result.skins = Lists.newArrayList(skins);
|
||||
}
|
||||
}catch(Exception e){
|
||||
CustomSkinLoader.logger.warning("Exception occurs while parsing index file: "+e.toString());
|
||||
}
|
||||
}
|
||||
|
||||
if(!CustomSkinLoader.config.enableDynamicSkull||result.skins==null||result.skins.isEmpty())
|
||||
return;
|
||||
|
||||
CustomSkinLoader.logger.info("Try to load Dynamic Skull: "+json);
|
||||
|
||||
for(int i=0;i<result.skins.size();i++){//check and cache skins
|
||||
String skin=result.skins.get(i);
|
||||
if(HttpUtil0.isLocal(skin)){
|
||||
//Local Skin
|
||||
File skinFile=new File(CustomSkinLoader.DATA_DIR,skin);
|
||||
if(skinFile.isFile()&&skinFile.length()>0){
|
||||
//Skin found
|
||||
String fakeUrl=HttpTextureUtil.getLocalFakeUrl(skin);
|
||||
result.skins.set(i, fakeUrl);
|
||||
}else{
|
||||
//Could not find skin
|
||||
result.skins.remove(i--);
|
||||
}
|
||||
}else{
|
||||
//Online Skin
|
||||
HttpResponce responce=HttpRequestUtil.makeHttpRequest(new HttpRequest(skin).setCacheFile(HttpTextureUtil.getCacheFile(FilenameUtils.getBaseName(skin))).setCacheTime(0).setLoadContent(false));
|
||||
if(!responce.success){
|
||||
//Could not load skin
|
||||
result.skins.remove(i--);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if(result.skins.isEmpty()){//Nothing loaded
|
||||
CustomSkinLoader.logger.info("Failed: Nothing loaded.");
|
||||
return;
|
||||
}
|
||||
result.interval=Math.max(result.interval, 50);
|
||||
if(result.fromZero)
|
||||
result.startTime=System.currentTimeMillis();
|
||||
result.period=result.interval*result.skins.size();
|
||||
CustomSkinLoader.logger.info("Successfully loaded Dynamic Skull: "+new Gson().toJson(result));
|
||||
dynamicTextures.put(profile, result);
|
||||
staticTextures.remove(profile);
|
||||
}
|
||||
|
||||
//Support local skin for skull
|
||||
public Map<Type, MinecraftProfileTexture> parseTextures(Map<Type, MinecraftProfileTexture> textures) {
|
||||
MinecraftProfileTexture skin=textures.get(Type.SKIN);
|
||||
String skinUrl=skin.getUrl();
|
||||
if(!HttpUtil0.isLocal(skinUrl))
|
||||
return textures;
|
||||
File skinFile=new File(CustomSkinLoader.DATA_DIR,skinUrl);
|
||||
if(!skinFile.isFile())
|
||||
return Maps.newHashMap();
|
||||
textures.put(Type.SKIN, ModelManager0.getProfileTexture(HttpTextureUtil.getLocalFakeUrl(skinUrl), null));
|
||||
return textures;
|
||||
}
|
||||
|
||||
public Map<Type,MinecraftProfileTexture> getTexture(final GameProfile profile){
|
||||
if(staticTextures.get(profile)!=null)
|
||||
return staticTextures.get(profile);
|
||||
if(loadingList.contains(profile))
|
||||
return Maps.newHashMap();
|
||||
if(dynamicTextures.containsKey(profile)){
|
||||
SkullTexture texture=dynamicTextures.get(profile);
|
||||
long time=System.currentTimeMillis()-texture.startTime;
|
||||
int index=(int)Math.floor((time%texture.period)/texture.interval);
|
||||
Map<Type,MinecraftProfileTexture> map=Maps.newHashMap();
|
||||
map.put(Type.SKIN, ModelManager0.getProfileTexture(texture.skins.get(index), null));
|
||||
return map;
|
||||
}
|
||||
|
||||
loadingList.add(profile);
|
||||
Thread loadThread=new Thread(){
|
||||
public void run(){
|
||||
parseGameProfile(profile);//Load in thread
|
||||
loadingList.remove(profile);
|
||||
}
|
||||
};
|
||||
loadThread.setName("Skull "+profile.hashCode());
|
||||
loadThread.start();
|
||||
return Maps.newHashMap();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,130 @@
|
||||
package customskinloader.profile;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
import com.google.common.collect.Maps;
|
||||
import com.mojang.authlib.minecraft.MinecraftProfileTexture;
|
||||
import customskinloader.fake.FakeMinecraftProfileTexture;
|
||||
import org.apache.commons.lang3.StringUtils;
|
||||
|
||||
/**
|
||||
* Model Manager for 1.8 and higher.
|
||||
* A manager to check if model is available.
|
||||
* It is the only class in package 'customskinloader' which has differences in different Minecraft version.
|
||||
*
|
||||
* @since 13.1
|
||||
*/
|
||||
public class ModelManager0 {
|
||||
public enum Model {
|
||||
SKIN_DEFAULT,
|
||||
SKIN_SLIM,
|
||||
CAPE,
|
||||
ELYTRA
|
||||
}
|
||||
|
||||
private static HashMap<String, Model> models = new HashMap<String, Model>();
|
||||
private static MinecraftProfileTexture.Type typeElytra = null;
|
||||
|
||||
static {
|
||||
for (MinecraftProfileTexture.Type type : MinecraftProfileTexture.Type.values()) {
|
||||
if (type.ordinal() == 2)//ELYTRA
|
||||
typeElytra = type;
|
||||
}
|
||||
models.put("default", Model.SKIN_DEFAULT);
|
||||
models.put("slim", Model.SKIN_SLIM);
|
||||
models.put("cape", Model.CAPE);
|
||||
if (typeElytra != null) {
|
||||
models.put("elytra", Model.ELYTRA);
|
||||
models.put("elytron", Model.ELYTRA);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get enum for the model.
|
||||
*
|
||||
* @param model - string model
|
||||
* @since 14.5
|
||||
*/
|
||||
public static Model getEnumModel(String model) {
|
||||
return models.get(model);
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if model is skin.
|
||||
*
|
||||
* @since 14.5
|
||||
*/
|
||||
public static boolean isSkin(Model model) {
|
||||
return model == Model.SKIN_DEFAULT || model == Model.SKIN_SLIM;
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if elytra is supported.
|
||||
*
|
||||
* @since 14.5
|
||||
*/
|
||||
public static boolean isElytraSupported() {
|
||||
return typeElytra != null;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse hashMapProfile to UserProfile
|
||||
*
|
||||
* @param profile - hashMapProfile (HashMap<String,MinecraftProfileTexture>)
|
||||
* @return profile - UserProfile instance
|
||||
* @since 13.1
|
||||
*/
|
||||
public static UserProfile toUserProfile(Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> profile) {
|
||||
UserProfile userProfile = new UserProfile();
|
||||
if (profile == null)
|
||||
return userProfile;
|
||||
MinecraftProfileTexture skin = profile.get(MinecraftProfileTexture.Type.SKIN);
|
||||
userProfile.skinUrl = skin == null ? null : skin.getUrl();//Avoid NullPointerException
|
||||
userProfile.model = skin == null ? null : skin.getMetadata("model");
|
||||
if (StringUtils.isEmpty(userProfile.model))
|
||||
userProfile.model = "default";
|
||||
|
||||
MinecraftProfileTexture cape = profile.get(MinecraftProfileTexture.Type.CAPE);
|
||||
userProfile.capeUrl = cape == null ? null : cape.getUrl();
|
||||
return userProfile;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse UserProfile to hashMapProfile
|
||||
*
|
||||
* @param profile - UserProfile instance
|
||||
* @return profile - hashMapProfile (HashMap<String,MinecraftProfileTexture>)
|
||||
* @since 13.1
|
||||
*/
|
||||
public static Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> fromUserProfile(UserProfile profile) {
|
||||
Map<MinecraftProfileTexture.Type, MinecraftProfileTexture> map = Maps.newHashMap();
|
||||
if (profile == null)
|
||||
return map;
|
||||
if (profile.skinUrl != null) {
|
||||
Map<String, String> metadata = null;
|
||||
if ("slim".equals(profile.model) || "auto".equals(profile.model)) {
|
||||
metadata = Maps.newHashMap();
|
||||
metadata.put("model", profile.model);
|
||||
}
|
||||
map.put(MinecraftProfileTexture.Type.SKIN, getProfileTexture(profile.skinUrl, metadata));
|
||||
}
|
||||
if (profile.capeUrl != null)
|
||||
map.put(MinecraftProfileTexture.Type.CAPE, getProfileTexture(profile.capeUrl, null));
|
||||
if (typeElytra != null && profile.elytraUrl != null)
|
||||
map.put(typeElytra, getProfileTexture(profile.elytraUrl, null));
|
||||
return map;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse url to MinecraftProfileTexture
|
||||
*
|
||||
* @param url - textureUrl
|
||||
* @param metadata - metadata
|
||||
* @return MinecraftProfileTexture
|
||||
* @since 14.5
|
||||
*/
|
||||
public static MinecraftProfileTexture getProfileTexture(String url, Map<String, String> metadata) {
|
||||
return new FakeMinecraftProfileTexture(url, metadata);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,126 @@
|
||||
package customskinloader.profile;
|
||||
|
||||
import java.io.File;
|
||||
import java.util.Deque;
|
||||
import java.util.Map;
|
||||
import java.util.Optional;
|
||||
import java.util.concurrent.ConcurrentHashMap;
|
||||
import java.util.concurrent.ConcurrentLinkedDeque;
|
||||
import java.util.function.Consumer;
|
||||
|
||||
import com.mojang.authlib.minecraft.MinecraftProfileTexture;
|
||||
import customskinloader.CustomSkinLoader;
|
||||
import customskinloader.utils.TimeUtil;
|
||||
import org.apache.commons.io.FileUtils;
|
||||
|
||||
public class ProfileCache {
|
||||
public static File PROFILE_CACHE_DIR=new File(CustomSkinLoader.DATA_DIR,"ProfileCache");
|
||||
|
||||
private Map<String, CachedProfile> cachedProfiles = new ConcurrentHashMap<>();
|
||||
private Map<String, UserProfile> localProfiles = new ConcurrentHashMap<>();
|
||||
private Map<String, Deque<Consumer<Map<MinecraftProfileTexture.Type, MinecraftProfileTexture>>>> profileLoaders = new ConcurrentHashMap<>();
|
||||
|
||||
@SuppressWarnings("ResultOfMethodCallIgnored")
|
||||
public ProfileCache(){
|
||||
if(!PROFILE_CACHE_DIR.exists())
|
||||
PROFILE_CACHE_DIR.mkdir();
|
||||
}
|
||||
|
||||
public boolean isExist(String username){
|
||||
return cachedProfiles.containsKey(username.toLowerCase());
|
||||
}
|
||||
public boolean isLoading(String username) {
|
||||
CachedProfile cp=cachedProfiles.get(username.toLowerCase());
|
||||
return cp != null && cp.loading;
|
||||
}
|
||||
public boolean isReady(String username){
|
||||
CachedProfile cp=cachedProfiles.get(username.toLowerCase());
|
||||
return cp != null && (cp.loading || cp.expiryTime > TimeUtil.getCurrentUnixTimestamp());
|
||||
}
|
||||
public boolean isExpired(String username){
|
||||
CachedProfile cp=cachedProfiles.get(username.toLowerCase());
|
||||
return cp == null || (cp.expiryTime <= TimeUtil.getCurrentUnixTimestamp());
|
||||
}
|
||||
|
||||
public UserProfile getProfile(String username){
|
||||
return getCachedProfile(username).profile;
|
||||
}
|
||||
public long getExpiry(String username){
|
||||
return getCachedProfile(username).expiryTime;
|
||||
}
|
||||
public UserProfile getLocalProfile(String username){
|
||||
if(localProfiles.containsKey(username.toLowerCase()))
|
||||
return localProfiles.get(username.toLowerCase());
|
||||
return loadLocalProfile(username);
|
||||
}
|
||||
public Optional<Consumer<Map<MinecraftProfileTexture.Type, MinecraftProfileTexture>>> getLastLoader(String username) {
|
||||
Deque<Consumer<Map<MinecraftProfileTexture.Type, MinecraftProfileTexture>>> deque = this.profileLoaders.get(username);
|
||||
if (deque != null) {
|
||||
return Optional.ofNullable(deque.pollLast());
|
||||
}
|
||||
return Optional.empty();
|
||||
}
|
||||
|
||||
public void setLoading(String username,boolean loading){
|
||||
getCachedProfile(username).loading=loading;
|
||||
}
|
||||
public void updateCache(String username,UserProfile profile){
|
||||
updateCache(username,profile,CustomSkinLoader.config.enableLocalProfileCache);
|
||||
}
|
||||
public void updateCache(String username,UserProfile profile,boolean saveLocalProfile){
|
||||
CachedProfile cp=getCachedProfile(username);
|
||||
cp.profile=profile;
|
||||
cp.expiryTime=TimeUtil.getUnixTimestamp(CustomSkinLoader.config.cacheExpiry);
|
||||
if(!saveLocalProfile)
|
||||
return;
|
||||
saveLocalProfile(username,profile);
|
||||
}
|
||||
public void putLoader(String username, Consumer<Map<MinecraftProfileTexture.Type, MinecraftProfileTexture>> loader) {
|
||||
this.profileLoaders.putIfAbsent(username, new ConcurrentLinkedDeque<>());
|
||||
this.profileLoaders.get(username).offerLast(loader);
|
||||
}
|
||||
|
||||
private CachedProfile getCachedProfile(String username){
|
||||
CachedProfile cp=cachedProfiles.get(username.toLowerCase());
|
||||
if(cp!=null)
|
||||
return cp;
|
||||
cp=new CachedProfile();
|
||||
cachedProfiles.put(username.toLowerCase(), cp);
|
||||
return cp;
|
||||
}
|
||||
private UserProfile loadLocalProfile(String username){
|
||||
File localProfile=new File(PROFILE_CACHE_DIR,username.toLowerCase()+".json");
|
||||
if(!localProfile.exists()){
|
||||
localProfiles.put(username.toLowerCase(), null);
|
||||
}
|
||||
try{
|
||||
String json = FileUtils.readFileToString(localProfile, "UTF-8");
|
||||
UserProfile profile=CustomSkinLoader.GSON.fromJson(json, UserProfile.class);
|
||||
localProfiles.put(username.toLowerCase(), profile);
|
||||
CustomSkinLoader.logger.info("Successfully load LocalProfile.");
|
||||
return profile;
|
||||
}catch(Exception e){
|
||||
CustomSkinLoader.logger.info("Failed to load LocalProfile.("+e.toString()+")");
|
||||
localProfiles.put(username.toLowerCase(), null);
|
||||
}
|
||||
return null;
|
||||
}
|
||||
@SuppressWarnings("ResultOfMethodCallIgnored")
|
||||
private void saveLocalProfile(String username, UserProfile profile){
|
||||
String json=CustomSkinLoader.GSON.toJson(profile);
|
||||
File localProfile=new File(PROFILE_CACHE_DIR,username+".json");
|
||||
if(localProfile.exists())
|
||||
localProfile.delete();
|
||||
try {
|
||||
FileUtils.write(localProfile, json, "UTF-8");
|
||||
CustomSkinLoader.logger.info("Successfully save LocalProfile.");
|
||||
} catch (Exception e) {
|
||||
CustomSkinLoader.logger.info("Failed to save LocalProfile.("+e.toString()+")");
|
||||
}
|
||||
}
|
||||
}
|
||||
class CachedProfile{
|
||||
public UserProfile profile;
|
||||
public long expiryTime=0;
|
||||
public boolean loading=false;
|
||||
}
|
||||
@@ -0,0 +1,103 @@
|
||||
package customskinloader.profile;
|
||||
|
||||
import org.apache.commons.lang3.StringUtils;
|
||||
|
||||
import customskinloader.profile.ModelManager0.Model;
|
||||
|
||||
/**The instance to storage user's profile in memory temporarily.
|
||||
* In this manner, it could be easier to pass profile in program.
|
||||
* @since 13.1
|
||||
*/
|
||||
public class UserProfile {
|
||||
|
||||
/**
|
||||
* Direct url for skin.
|
||||
* @since 13.1
|
||||
*/
|
||||
public String skinUrl=null;
|
||||
|
||||
/**
|
||||
* Model for skin.
|
||||
* default/slim
|
||||
* @since 13.1
|
||||
*/
|
||||
public String model=null;
|
||||
|
||||
/**
|
||||
* Direct url for cape.
|
||||
* @since 13.1
|
||||
*/
|
||||
public String capeUrl=null;
|
||||
|
||||
/**
|
||||
* Direct url for elytra.
|
||||
* @since 14.5
|
||||
*/
|
||||
public String elytraUrl=null;
|
||||
|
||||
public void put(Model model,String url){
|
||||
if(model==null||StringUtils.isEmpty(url))
|
||||
return;
|
||||
switch(model){
|
||||
case SKIN_DEFAULT:
|
||||
this.skinUrl=url;
|
||||
this.model="default";
|
||||
return;
|
||||
case SKIN_SLIM:
|
||||
this.skinUrl=url;
|
||||
this.model="slim";
|
||||
return;
|
||||
case CAPE:
|
||||
this.capeUrl=url;
|
||||
return;
|
||||
case ELYTRA:
|
||||
this.elytraUrl = url;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get parsed String to output the instance.
|
||||
*/
|
||||
@Override
|
||||
public String toString(){
|
||||
return toString(0);
|
||||
}
|
||||
public String toString(long expiry){
|
||||
return "(SkinUrl: "+skinUrl+
|
||||
" , Model: "+model+
|
||||
" , CapeUrl: "+capeUrl+
|
||||
(StringUtils.isBlank(elytraUrl)?" ":" , ElytraUrl: "+elytraUrl)+
|
||||
(expiry==0?"":(" , Expiry: "+expiry))+")";
|
||||
}
|
||||
|
||||
/**
|
||||
* Check if the instance is empty.
|
||||
* @return status (true - empty)
|
||||
*/
|
||||
public boolean isEmpty(){
|
||||
return StringUtils.isEmpty(skinUrl) && StringUtils.isEmpty(capeUrl) && StringUtils.isEmpty(elytraUrl);
|
||||
}
|
||||
/**
|
||||
* Check if the instance is full(Both skin and cape).
|
||||
* @return status (true - full)
|
||||
* @since 14.7
|
||||
*/
|
||||
public boolean isFull(){
|
||||
return StringUtils.isNoneBlank(skinUrl,capeUrl);
|
||||
}
|
||||
public boolean hasSkinUrl(){
|
||||
return StringUtils.isNotEmpty(skinUrl);
|
||||
}
|
||||
public void mix(UserProfile profile){
|
||||
if(profile==null)
|
||||
return;
|
||||
if(StringUtils.isEmpty(this.skinUrl)) {
|
||||
this.skinUrl = profile.skinUrl;
|
||||
this.model = profile.model;
|
||||
}
|
||||
if(StringUtils.isEmpty(this.capeUrl))
|
||||
this.capeUrl=profile.capeUrl;
|
||||
if(StringUtils.isEmpty(this.elytraUrl))
|
||||
this.elytraUrl=profile.elytraUrl;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,282 @@
|
||||
package customskinloader.utils;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.IOException;
|
||||
import java.io.InputStream;
|
||||
import java.io.OutputStream;
|
||||
import java.net.HttpURLConnection;
|
||||
import java.net.URI;
|
||||
import java.net.URL;
|
||||
import java.nio.charset.StandardCharsets;
|
||||
import java.util.regex.Matcher;
|
||||
import java.util.regex.Pattern;
|
||||
import java.util.zip.GZIPInputStream;
|
||||
|
||||
import org.apache.commons.codec.digest.DigestUtils;
|
||||
import org.apache.commons.io.FileUtils;
|
||||
import org.apache.commons.io.IOUtils;
|
||||
import org.apache.commons.lang3.StringUtils;
|
||||
|
||||
import customskinloader.CustomSkinLoader;
|
||||
|
||||
public class HttpRequestUtil {
|
||||
public static class HttpRequest {
|
||||
public String url;
|
||||
public String userAgent = null;
|
||||
public String payload = null;
|
||||
public boolean loadContent = true;
|
||||
public boolean checkPNG = false;
|
||||
|
||||
/**
|
||||
* Cache Time
|
||||
* -1=No Cache 0=Always Cache t=Default Cache Time(second)
|
||||
*/
|
||||
public int cacheTime = 600;
|
||||
public File cacheFile = null;//Default Cache File
|
||||
|
||||
public HttpRequest(String url) {
|
||||
this.url = url;
|
||||
}
|
||||
|
||||
public HttpRequest setUserAgent(String userAgent) {
|
||||
this.userAgent = userAgent;
|
||||
return this;
|
||||
}
|
||||
|
||||
public HttpRequest setPayload(String payload) {
|
||||
this.payload = payload;
|
||||
return this;
|
||||
}
|
||||
|
||||
public HttpRequest setLoadContent(boolean loadContent) {
|
||||
this.loadContent = loadContent;
|
||||
return this;
|
||||
}
|
||||
|
||||
public HttpRequest setCheckPNG(boolean checkPNG) {
|
||||
this.checkPNG = checkPNG;
|
||||
return this;
|
||||
}
|
||||
|
||||
public HttpRequest setCacheTime(int cacheTime) {
|
||||
this.cacheTime = cacheTime;
|
||||
return this;
|
||||
}
|
||||
|
||||
public HttpRequest setCacheFile(File cacheFile) {
|
||||
this.cacheFile = cacheFile;
|
||||
return this;
|
||||
}
|
||||
}
|
||||
|
||||
public static class HttpResponce {
|
||||
public String content = null;
|
||||
public int responceCode = -1;
|
||||
public boolean success = false;
|
||||
public boolean fromCache = false;
|
||||
}
|
||||
|
||||
public static class CacheInfo {
|
||||
public String url;
|
||||
public String etag = null;
|
||||
|
||||
public long lastModified = -1;//ms
|
||||
public long expire = -1;//UNIX timestamp
|
||||
}
|
||||
|
||||
public static final File CACHE_DIR = new File(CustomSkinLoader.DATA_DIR, "caches");
|
||||
|
||||
public static HttpResponce makeHttpRequest(HttpRequest request) {
|
||||
return makeHttpRequest(request, 0);
|
||||
}
|
||||
|
||||
public static HttpResponce makeHttpRequest(HttpRequest request, int redirectTime) {
|
||||
try {
|
||||
//No url provided, try to load from special cache file
|
||||
if (request.url == null || request.url.isEmpty()) {
|
||||
CustomSkinLoader.logger.debug("Try to read cache '" + request.cacheFile + "'.");
|
||||
return loadFromCache(request, new HttpResponce());
|
||||
}
|
||||
CustomSkinLoader.logger.debug("Try to request '" + request.url + (request.userAgent == null ? "'." : "' with user agent '" + request.userAgent + "'."));
|
||||
//Check Cache
|
||||
if (StringUtils.isNotEmpty(request.payload) || CustomSkinLoader.config.forceDisableCache) {
|
||||
request.cacheTime = -1;//No Cache
|
||||
}
|
||||
File cacheInfoFile = null;
|
||||
CacheInfo cacheInfo = new CacheInfo();
|
||||
if (request.cacheFile == null && request.cacheTime >= 0) {
|
||||
String hash = DigestUtils.sha1Hex(request.url);
|
||||
request.cacheFile = new File(CACHE_DIR, hash);
|
||||
cacheInfoFile = new File(CACHE_DIR, hash + ".json");
|
||||
}
|
||||
//noinspection BulkFileAttributesRead
|
||||
if (request.cacheTime == 0 && request.cacheFile.isFile()) {
|
||||
return loadFromCache(request, new HttpResponce());
|
||||
}
|
||||
if (cacheInfoFile != null && cacheInfoFile.isFile()) {
|
||||
String json = FileUtils.readFileToString(cacheInfoFile, "UTF-8");
|
||||
if (StringUtils.isNotEmpty(json)) {
|
||||
cacheInfo = CustomSkinLoader.GSON.fromJson(json, CacheInfo.class);
|
||||
}
|
||||
if (cacheInfo == null) {
|
||||
cacheInfo = new CacheInfo();
|
||||
}
|
||||
if (cacheInfo.expire >= TimeUtil.getCurrentUnixTimestamp()) {
|
||||
return loadFromCache(request, new HttpResponce(), cacheInfo.expire);
|
||||
}
|
||||
}
|
||||
|
||||
//Init Connection
|
||||
URL rawUrl = new URL(request.url);
|
||||
URI uri = new URI(
|
||||
rawUrl.getProtocol(),
|
||||
rawUrl.getUserInfo(),
|
||||
rawUrl.getHost(),
|
||||
rawUrl.getPort(),
|
||||
rawUrl.getPath(),
|
||||
rawUrl.getQuery(),
|
||||
rawUrl.getRef()
|
||||
);
|
||||
String url = uri.toASCIIString();
|
||||
if (!url.equalsIgnoreCase(request.url)) {
|
||||
CustomSkinLoader.logger.debug("Encoded URL: " + url);
|
||||
}
|
||||
HttpURLConnection c = (HttpURLConnection) (new URL(url)).openConnection();
|
||||
c.setReadTimeout(1000 * 10);
|
||||
c.setConnectTimeout(1000 * 10);
|
||||
c.setDoInput(true);
|
||||
c.setUseCaches(false);
|
||||
c.setInstanceFollowRedirects(true);
|
||||
|
||||
//Make Connection
|
||||
if (cacheInfo.lastModified >= 0) {
|
||||
c.setIfModifiedSince(cacheInfo.lastModified);
|
||||
}
|
||||
if (cacheInfo.etag != null) {
|
||||
c.setRequestProperty("If-None-Match", cacheInfo.etag);
|
||||
}
|
||||
c.setRequestProperty("Accept-Encoding", "gzip");
|
||||
if (request.userAgent != null) {
|
||||
c.setRequestProperty("User-Agent", request.userAgent);
|
||||
}
|
||||
if (StringUtils.isNotEmpty(request.payload)) {
|
||||
CustomSkinLoader.logger.info("Payload: " + request.payload);
|
||||
c.setRequestMethod("POST");
|
||||
c.setRequestProperty("Content-Type", "application/json");
|
||||
c.setDoOutput(true);
|
||||
OutputStream os = c.getOutputStream();
|
||||
IOUtils.write(request.payload, os, "UTF-8");
|
||||
IOUtils.closeQuietly(os);
|
||||
}
|
||||
c.connect();
|
||||
|
||||
//Check Connection
|
||||
HttpResponce responce = new HttpResponce();
|
||||
responce.responceCode = c.getResponseCode();
|
||||
int res = c.getResponseCode();
|
||||
if (res / 100 == 4 || res / 100 == 5) {//Failed
|
||||
CustomSkinLoader.logger.debug("Failed to request (Response Code: " + res + ")");
|
||||
return responce;
|
||||
}
|
||||
if (res == HttpURLConnection.HTTP_MOVED_PERM || res == HttpURLConnection.HTTP_MOVED_TEMP) {
|
||||
//Redirect
|
||||
if (redirectTime >= 4) {
|
||||
CustomSkinLoader.logger.debug("Failed to request (Too many redirection)");
|
||||
return responce;
|
||||
}
|
||||
request.url = c.getHeaderField("Location");//Get redirecting location
|
||||
if (request.url == null) {
|
||||
CustomSkinLoader.logger.debug("Failed to request (Redirecting location not found)");
|
||||
return responce;
|
||||
}
|
||||
CustomSkinLoader.logger.debug("Redirect to: " + request.url);
|
||||
return makeHttpRequest(request, redirectTime + 1);//Recursion
|
||||
}
|
||||
responce.success = true;
|
||||
CustomSkinLoader.logger.debug("Successfully request (Response Code: " + res + " , Content Length: " + c.getContentLength() + ")");
|
||||
if (responce.responceCode == HttpURLConnection.HTTP_NOT_MODIFIED) {
|
||||
return loadFromCache(request, responce);
|
||||
}
|
||||
if (responce.responceCode == HttpURLConnection.HTTP_NO_CONTENT) {
|
||||
request.cacheTime = 3600;
|
||||
}
|
||||
|
||||
//Load Content
|
||||
InputStream is = "gzip".equals(c.getContentEncoding()) ? new GZIPInputStream(c.getInputStream()) : c.getInputStream();
|
||||
byte[] bytes = IOUtils.toByteArray(is);
|
||||
if (request.checkPNG && (bytes.length <= 4 || bytes[1] != (byte) 'P' || bytes[2] != (byte) 'N' || bytes[3] != (byte) 'G')) {
|
||||
CustomSkinLoader.logger.debug("Failed to request (Not Standard PNG)");
|
||||
responce.success = false;
|
||||
return responce;
|
||||
}
|
||||
if (request.cacheFile != null) {
|
||||
FileUtils.writeByteArrayToFile(request.cacheFile, bytes);
|
||||
if (cacheInfoFile != null) {
|
||||
cacheInfo.url = request.url;
|
||||
cacheInfo.etag = c.getHeaderField("ETag");
|
||||
cacheInfo.lastModified = c.getLastModified();
|
||||
cacheInfo.expire = getExpire(c, request.cacheTime);
|
||||
FileUtils.write(cacheInfoFile, CustomSkinLoader.GSON.toJson(cacheInfo), "UTF-8");
|
||||
}
|
||||
//noinspection BulkFileAttributesRead
|
||||
CustomSkinLoader.logger.debug("Saved to cache (Length: " + request.cacheFile.length() + " , Path: '" + request.cacheFile.getAbsolutePath() + "' , Expire: " + cacheInfo.expire + ")");
|
||||
}
|
||||
if (!request.loadContent) {
|
||||
return responce;
|
||||
}
|
||||
responce.content = new String(bytes, StandardCharsets.UTF_8);
|
||||
CustomSkinLoader.logger.debug("Content: " + responce.content);
|
||||
return responce;
|
||||
|
||||
} catch (Exception e) {
|
||||
CustomSkinLoader.logger.debug("Failed to request " + request.url + " (Exception: " + e + ")");
|
||||
return loadFromCache(request, new HttpResponce());
|
||||
}
|
||||
}
|
||||
|
||||
public static File getCacheFile(String hash) {
|
||||
return new File(CACHE_DIR, hash);
|
||||
}
|
||||
|
||||
private static HttpResponce loadFromCache(HttpRequest request, HttpResponce responce) {
|
||||
return loadFromCache(request, responce, 0);
|
||||
}
|
||||
|
||||
private static HttpResponce loadFromCache(HttpRequest request, HttpResponce responce, long expireTime) {
|
||||
if (request.cacheFile == null || !request.cacheFile.isFile()) {
|
||||
return responce;
|
||||
}
|
||||
CustomSkinLoader.logger.debug("Cache file found (Length: " + request.cacheFile.length() + " , Path: '" + request.cacheFile.getAbsolutePath() + "' , Expire: " + expireTime + ")");
|
||||
responce.fromCache = true;
|
||||
responce.success = true;
|
||||
if (!request.loadContent) {
|
||||
return responce;
|
||||
}
|
||||
|
||||
CustomSkinLoader.logger.info("Try to load from cache '" + request.cacheFile.getAbsolutePath() + "'.");
|
||||
try {
|
||||
responce.content = FileUtils.readFileToString(request.cacheFile, "UTF-8");
|
||||
CustomSkinLoader.logger.debug("Successfully load from cache");
|
||||
CustomSkinLoader.logger.debug("Content: " + responce.content);
|
||||
} catch (IOException e) {
|
||||
CustomSkinLoader.logger.debug("Failed to load from cache (Exception: " + e + ")");
|
||||
responce.success = false;
|
||||
}
|
||||
return responce;
|
||||
}
|
||||
|
||||
private final static Pattern MAX_AGE_PATTERN = Pattern.compile(".*?max-age=(\\d+).*?");
|
||||
|
||||
private static long getExpire(HttpURLConnection connection, int cacheTime) {
|
||||
String cacheControl = connection.getHeaderField("Cache-Control");
|
||||
if (StringUtils.isNotEmpty(cacheControl)) {
|
||||
Matcher m = MAX_AGE_PATTERN.matcher(cacheControl);
|
||||
if (m.matches())
|
||||
return TimeUtil.getUnixTimestamp(Long.parseLong(m.group(m.groupCount())));
|
||||
}
|
||||
long expires = connection.getExpiration();
|
||||
if (expires > 0)
|
||||
return expires / 1000;
|
||||
return TimeUtil.getUnixTimestampRandomDelay(cacheTime == 0 ? 2592000 : cacheTime);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,107 @@
|
||||
package customskinloader.utils;
|
||||
|
||||
import java.io.File;
|
||||
|
||||
import org.apache.commons.codec.digest.DigestUtils;
|
||||
import org.apache.commons.io.FilenameUtils;
|
||||
|
||||
import customskinloader.CustomSkinLoader;
|
||||
|
||||
public class HttpTextureUtil {
|
||||
public static class HttpTextureInfo {
|
||||
public String url = "";
|
||||
public File cacheFile;
|
||||
public String hash;
|
||||
}
|
||||
|
||||
private static final String
|
||||
LEGACY_MARK = "(LEGACY)",
|
||||
LOCAL_MARK = "(LOCAL)",
|
||||
LOCAL_LEGACY_MARK = "(LOCAL_LEGACY)",
|
||||
BASE64_MARK = "(BASE64)";
|
||||
public static File defaultCacheDir;
|
||||
|
||||
@SuppressWarnings("ResultOfMethodCallIgnored")
|
||||
public static void cleanCacheDir() {
|
||||
if (defaultCacheDir != null) {
|
||||
defaultCacheDir.delete();
|
||||
defaultCacheDir.mkdirs();
|
||||
}
|
||||
}
|
||||
|
||||
public static File getCacheDir() {
|
||||
return defaultCacheDir == null ? new File(MinecraftUtil.getMinecraftDataDir(), "assets/skins") : defaultCacheDir;
|
||||
}
|
||||
|
||||
public static HttpTextureInfo toHttpTextureInfo(String fakeUrl) {
|
||||
HttpTextureInfo info = new HttpTextureInfo();
|
||||
if (fakeUrl.startsWith("http")) {
|
||||
info.url = fakeUrl;
|
||||
info.hash = FilenameUtils.getBaseName(fakeUrl);
|
||||
info.cacheFile = getCacheFile(info.hash);
|
||||
return info;
|
||||
}
|
||||
if (fakeUrl.startsWith(LOCAL_LEGACY_MARK)) {
|
||||
fakeUrl = fakeUrl.replace(LOCAL_LEGACY_MARK, "");
|
||||
String[] t = fakeUrl.split(",", 2);
|
||||
if (t.length != 2)
|
||||
return info;
|
||||
info.cacheFile = new File(CustomSkinLoader.DATA_DIR, t[1]);
|
||||
info.hash = t[0];
|
||||
return info;
|
||||
}
|
||||
if (fakeUrl.startsWith(LOCAL_MARK)) {
|
||||
fakeUrl = fakeUrl.replace(LOCAL_MARK, "");
|
||||
info.cacheFile = new File(CustomSkinLoader.DATA_DIR, fakeUrl);
|
||||
info.hash = FilenameUtils.getBaseName(fakeUrl);
|
||||
return info;
|
||||
}
|
||||
if (fakeUrl.startsWith(LEGACY_MARK)) {
|
||||
fakeUrl = fakeUrl.replace(LEGACY_MARK, "");
|
||||
info.url = fakeUrl;
|
||||
info.hash = DigestUtils.sha1Hex(info.url);
|
||||
info.cacheFile = HttpRequestUtil.getCacheFile(info.hash);
|
||||
return info;
|
||||
}
|
||||
//Base64 fake url format: `(BASE64)${hash}`
|
||||
if (fakeUrl.startsWith(BASE64_MARK)) {
|
||||
fakeUrl = fakeUrl.replace(BASE64_MARK, "");
|
||||
info.hash = fakeUrl;
|
||||
info.cacheFile = getCacheFile(info.hash);
|
||||
return info;
|
||||
}
|
||||
return info;
|
||||
}
|
||||
|
||||
public static String getLegacyFakeUrl(String url) {
|
||||
return LEGACY_MARK + url;
|
||||
}
|
||||
|
||||
public static String getLocalFakeUrl(String path) {
|
||||
return LOCAL_MARK + path;
|
||||
}
|
||||
|
||||
public static String getLocalLegacyFakeUrl(String path, String hash) {
|
||||
return LOCAL_LEGACY_MARK + hash + "," + path;
|
||||
}
|
||||
|
||||
public static String getBase64FakeUrl(String hash) {
|
||||
return BASE64_MARK + hash;
|
||||
}
|
||||
|
||||
public static String getHash(String url, long size, long lastModified) {
|
||||
return DigestUtils.sha1Hex(size + url + lastModified);
|
||||
}
|
||||
|
||||
public static String getHash(byte[] bytes) {
|
||||
return DigestUtils.sha256Hex(bytes);
|
||||
}
|
||||
|
||||
public static File getCacheFile(String hash) {
|
||||
return getCacheFile(defaultCacheDir, hash);
|
||||
}
|
||||
|
||||
public static File getCacheFile(File cacheDir, String hash) {
|
||||
return new File(new File(cacheDir, hash.length() > 2 ? hash.substring(0, 2) : "xx"), hash);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,127 @@
|
||||
package customskinloader.utils;
|
||||
|
||||
import java.io.IOException;
|
||||
import java.net.InetAddress;
|
||||
import java.net.Socket;
|
||||
import java.net.UnknownHostException;
|
||||
import java.security.cert.X509Certificate;
|
||||
import javax.net.ssl.HostnameVerifier;
|
||||
import javax.net.ssl.HttpsURLConnection;
|
||||
import javax.net.ssl.SSLContext;
|
||||
import javax.net.ssl.SSLSession;
|
||||
import javax.net.ssl.SSLSocketFactory;
|
||||
import javax.net.ssl.TrustManager;
|
||||
import javax.net.ssl.X509TrustManager;
|
||||
|
||||
import org.apache.commons.lang3.StringUtils;
|
||||
|
||||
public class HttpUtil0 {
|
||||
public static boolean isLocal(String url){
|
||||
return url != null && !url.startsWith("http://") && !url.startsWith("https://");
|
||||
}
|
||||
|
||||
//From: http://blog.csdn.net/xiyushiyi/article/details/46685387
|
||||
public static void ignoreHttpsCertificate(){
|
||||
HostnameVerifier doNotVerify = new HostnameVerifier() {
|
||||
|
||||
public boolean verify(String hostname, SSLSession session) {
|
||||
return true;
|
||||
}
|
||||
};
|
||||
TrustManager[] trustAllCerts = new TrustManager[] {new X509TrustManager() {
|
||||
public X509Certificate[] getAcceptedIssuers() {
|
||||
return new X509Certificate[] {};
|
||||
}
|
||||
public void checkClientTrusted(X509Certificate[] chain, String authType){}
|
||||
public void checkServerTrusted(X509Certificate[] chain, String authType){}
|
||||
}};
|
||||
|
||||
try {
|
||||
SSLContext sc = SSLContext.getInstance("TLS");
|
||||
sc.init(null, trustAllCerts, new java.security.SecureRandom());
|
||||
//HttpsURLConnection.setDefaultSSLSocketFactory(sc.getSocketFactory());
|
||||
HttpsURLConnection.setDefaultSSLSocketFactory(new SSLSocketFactoryFacade());
|
||||
HttpsURLConnection.setDefaultHostnameVerifier(doNotVerify);
|
||||
} catch (Exception e) {
|
||||
e.printStackTrace();
|
||||
}
|
||||
}
|
||||
|
||||
public static String parseAddress(String address) {
|
||||
if(StringUtils.isEmpty(address))
|
||||
return null;
|
||||
String[] addresses=address.split(":");
|
||||
InetAddress add;
|
||||
try {
|
||||
add = InetAddress.getByName(addresses[0]);
|
||||
} catch (UnknownHostException e) {
|
||||
e.printStackTrace();
|
||||
return null;
|
||||
}
|
||||
return add.getHostAddress()+(addresses.length==2 ? addresses[1] : "25565");
|
||||
}
|
||||
public static boolean isLanServer(String standardAddress){
|
||||
if(StringUtils.isEmpty(standardAddress))
|
||||
return true;
|
||||
String[] addresses=standardAddress.split(":");
|
||||
int numIp=getNumIp(addresses[0]);
|
||||
return numIp==0||numIp==getNumIp("127.0.0.1")||
|
||||
(numIp>=getNumIp("192.168.0.0")&&numIp<=getNumIp("192.168.255.255"))||
|
||||
(numIp>=getNumIp("10.0.0.0")&&numIp<=getNumIp("10.255.255.255"))||
|
||||
(numIp>=getNumIp("172.16.0.0")&&numIp<=getNumIp("172.31.255.255"));
|
||||
}
|
||||
public static int getNumIp(String ip){
|
||||
int num=0;
|
||||
String[] ips=ip.split("\\.");
|
||||
if(ips.length!=4)
|
||||
return 0;
|
||||
for(int i=0;i<4;i++)
|
||||
num+=Integer.parseInt(ips[i])*(256^(3-i));
|
||||
return num;
|
||||
}
|
||||
|
||||
//https://stackoverflow.com/questions/30817934/extended-server-name-sni-extension-not-sent-with-jdk1-8-0-but-send-with-jdk1-7
|
||||
public static class SSLSocketFactoryFacade extends SSLSocketFactory {
|
||||
|
||||
SSLSocketFactory sslsf;
|
||||
|
||||
public SSLSocketFactoryFacade() {
|
||||
sslsf = (SSLSocketFactory) SSLSocketFactory.getDefault();;
|
||||
}
|
||||
|
||||
@Override
|
||||
public String[] getDefaultCipherSuites() {
|
||||
return sslsf.getDefaultCipherSuites();
|
||||
}
|
||||
|
||||
@Override
|
||||
public String[] getSupportedCipherSuites() {
|
||||
return sslsf.getSupportedCipherSuites();
|
||||
}
|
||||
|
||||
@Override
|
||||
public Socket createSocket(Socket socket, String s, int i, boolean b) throws IOException {
|
||||
return sslsf.createSocket(socket, s, i, b);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Socket createSocket(String s, int i) throws IOException, UnknownHostException {
|
||||
return sslsf.createSocket(s, i);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Socket createSocket(String s, int i, InetAddress inetAddress, int i1) throws IOException, UnknownHostException {
|
||||
return sslsf.createSocket(s, i, inetAddress, i1);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Socket createSocket(InetAddress inetAddress, int i) throws IOException {
|
||||
return createSocket(inetAddress, i);
|
||||
}
|
||||
|
||||
@Override
|
||||
public Socket createSocket(InetAddress inetAddress, int i, InetAddress inetAddress1, int i1) throws IOException {
|
||||
return createSocket(inetAddress, i, inetAddress1, i1);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
package customskinloader.utils;
|
||||
|
||||
import java.io.File;
|
||||
import java.net.URL;
|
||||
import java.net.URLClassLoader;
|
||||
import java.util.LinkedList;
|
||||
|
||||
public class JavaUtil {
|
||||
public static URL[] getClasspath() {
|
||||
if (JavaUtil.class.getClassLoader() instanceof URLClassLoader) {
|
||||
//Java 8-
|
||||
//Use URLClassLoader Directly
|
||||
URLClassLoader ucl = (URLClassLoader) JavaUtil.class.getClassLoader();
|
||||
return ucl.getURLs();
|
||||
} else {
|
||||
//Java 9+
|
||||
//It uses APPClassLoader instead of URLClassLoader
|
||||
//Get Classpath from properties and parse it to URL array
|
||||
String classpath = System.getProperty("java.class.path");
|
||||
String[] elements = classpath.split(File.pathSeparator);
|
||||
if (elements.length == 0)
|
||||
return new URL[0];
|
||||
LinkedList<URL> urls = new LinkedList<URL>();
|
||||
for (String ele : elements) {
|
||||
try {
|
||||
urls.add(new File(ele).toURI().toURL());
|
||||
} catch (Exception ignored) {
|
||||
}
|
||||
}
|
||||
return urls.toArray(new URL[0]);
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,91 @@
|
||||
package customskinloader.utils;
|
||||
|
||||
import java.io.File;
|
||||
import java.io.InputStream;
|
||||
import java.io.InputStreamReader;
|
||||
import java.lang.invoke.MethodHandle;
|
||||
import java.lang.invoke.MethodHandles;
|
||||
import java.net.URL;
|
||||
|
||||
import com.google.gson.JsonObject;
|
||||
import com.google.gson.JsonParser;
|
||||
import com.mojang.authlib.GameProfile;
|
||||
import net.minecraft.client.Minecraft;
|
||||
import net.minecraft.client.multiplayer.ServerData;
|
||||
import net.minecraft.client.renderer.texture.TextureManager;
|
||||
import net.minecraft.client.resources.SkinManager;
|
||||
|
||||
/**
|
||||
* @author Alexander Xia
|
||||
* @since 13.6
|
||||
*/
|
||||
public class MinecraftUtil {
|
||||
public static File getMinecraftDataDir() {
|
||||
return Minecraft.getMinecraft().gameDir;
|
||||
}
|
||||
|
||||
public static TextureManager getTextureManager() {
|
||||
return Minecraft.getMinecraft().getTextureManager();
|
||||
}
|
||||
|
||||
public static SkinManager getSkinManager() {
|
||||
return Minecraft.getMinecraft().getSkinManager();
|
||||
}
|
||||
private static String minecraftMainVersion = null;
|
||||
|
||||
public static String getMinecraftMainVersion() {
|
||||
//Check if cached version found
|
||||
if (minecraftMainVersion != null) {
|
||||
return minecraftMainVersion;
|
||||
}
|
||||
|
||||
//version.json can be found in 1.14+
|
||||
URL versionFile = MinecraftUtil.class.getResource("/version.json");
|
||||
if (versionFile != null) {
|
||||
try (
|
||||
InputStream is = versionFile.openStream();
|
||||
InputStreamReader isr = new InputStreamReader(is)
|
||||
) {
|
||||
JsonObject obj = new JsonParser().parse(isr).getAsJsonObject();
|
||||
minecraftMainVersion = obj.get("name").getAsString();
|
||||
return minecraftMainVersion;
|
||||
} catch (Exception ignored) {
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
//RealmsSharedConstants.VERSION_STRING is available in 1.16-
|
||||
try {
|
||||
Class<?> realmsSharedConstants = Class.forName("net.minecraft.realms.RealmsSharedConstants");
|
||||
MethodHandle mh = MethodHandles.publicLookup().findStaticGetter(realmsSharedConstants, "VERSION_STRING", String.class);
|
||||
minecraftMainVersion = (String) mh.invoke();
|
||||
return minecraftMainVersion;
|
||||
} catch (Throwable ignored) {
|
||||
}
|
||||
|
||||
//No version can be found
|
||||
return "unknown";
|
||||
}
|
||||
|
||||
// (domain|ip)(:port)
|
||||
public static String getServerAddress() {
|
||||
ServerData data = Minecraft.getMinecraft().getCurrentServerData();
|
||||
if (data == null)//Single Player
|
||||
return null;
|
||||
return data.serverIP;
|
||||
}
|
||||
|
||||
// ip:port
|
||||
public static String getStandardServerAddress() {
|
||||
return HttpUtil0.parseAddress(getServerAddress());
|
||||
}
|
||||
|
||||
public static boolean isLanServer() {
|
||||
return HttpUtil0.isLanServer(getStandardServerAddress());
|
||||
}
|
||||
|
||||
public static String getCredential(GameProfile profile) {
|
||||
return (profile == null || profile.hashCode() == 0) ? null :
|
||||
(profile.getId() == null ? profile.getName() : String.format("%s-%s", profile.getName(), profile.getId()));
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,33 @@
|
||||
package customskinloader.utils;
|
||||
|
||||
import customskinloader.CustomSkinLoader;
|
||||
import org.apache.commons.codec.binary.Base64;
|
||||
import org.apache.commons.io.FileUtils;
|
||||
|
||||
import java.io.File;
|
||||
|
||||
public class TextureUtil {
|
||||
/**
|
||||
* Save and get fake url of base64 texture
|
||||
*
|
||||
* @param base64 texture in base64 string
|
||||
* @return base64 fake url
|
||||
* @since 14.16
|
||||
*/
|
||||
public static String parseBase64Texture(String base64) {
|
||||
byte[] capeBytes = Base64.decodeBase64(base64);
|
||||
String hash = HttpTextureUtil.getHash(capeBytes);
|
||||
File cacheFile = HttpTextureUtil.getCacheFile(hash);
|
||||
String fakeUrl = HttpTextureUtil.getBase64FakeUrl(hash);
|
||||
|
||||
//Save base64 image to cache file
|
||||
try {
|
||||
FileUtils.writeByteArrayToFile(cacheFile, capeBytes);
|
||||
CustomSkinLoader.logger.info("Saved base64 image to " + cacheFile);
|
||||
return fakeUrl;
|
||||
} catch (Exception e) {
|
||||
CustomSkinLoader.logger.warning("Error parsing base64 image: " + base64);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,17 @@
|
||||
package customskinloader.utils;
|
||||
|
||||
public class TimeUtil {
|
||||
public static long getCurrentUnixTimestamp(){
|
||||
return System.currentTimeMillis() / 1000L;
|
||||
}
|
||||
public static long getUnixTimestamp(long offset){
|
||||
return getCurrentUnixTimestamp()+offset;
|
||||
}
|
||||
public static long getUnixTimestampRandomDelay(long offset){
|
||||
return getCurrentUnixTimestamp()+offset+random(0,5);
|
||||
}
|
||||
|
||||
private static int random(int min,int max){
|
||||
return (int)(Math.random()*(max-min+1))+min;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,50 @@
|
||||
package customskinloader.utils;
|
||||
|
||||
import org.apache.commons.lang3.StringUtils;
|
||||
|
||||
public class Version implements Comparable {
|
||||
private String version;
|
||||
private int sub[];
|
||||
|
||||
public Version(String version) {
|
||||
if (version == null) version = "";
|
||||
this.version = version;
|
||||
|
||||
//Parse Subversion
|
||||
String[] split = version.split("\\.");
|
||||
sub = new int[split.length];
|
||||
for (int i = 0; i < split.length; i++) {
|
||||
if (StringUtils.isNumeric(split[i]))
|
||||
sub[i] = Integer.parseInt(split[i]);
|
||||
}
|
||||
}
|
||||
|
||||
public static Version of(String version) {
|
||||
return new Version(version);
|
||||
}
|
||||
|
||||
public static int compare(String version, String anotherVersion) {
|
||||
return Version.of(version).compareTo(anotherVersion);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
return version;
|
||||
}
|
||||
|
||||
@Override
|
||||
public int compareTo(Object o) {
|
||||
if (o instanceof String) o = Version.of((String) o);//Parse String version
|
||||
if (!(o instanceof Version)) throw new IllegalArgumentException(String.format("'%s' is not a Version.", o));
|
||||
|
||||
Version v = (Version) o;
|
||||
int i = 0;
|
||||
//Skip same subversion
|
||||
while (i < sub.length && i < v.sub.length && sub[i] == v.sub[i]) i++;
|
||||
//Compare first non-equal number
|
||||
if (i < sub.length && i < v.sub.length)
|
||||
return (sub[i] < v.sub[i]) ? -1 : ((sub[i] == v.sub[i]) ? 0 : 1); //Integer.compare(sub[i], v.sub[i]);
|
||||
//Compare length if all subversion is same
|
||||
return Integer.signum(sub.length - v.sub.length);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
package net.minecraft.client.renderer;
|
||||
|
||||
import java.awt.image.BufferedImage;
|
||||
|
||||
import net.minecraft.client.renderer.texture.NativeImage;
|
||||
|
||||
public interface IImageBuffer extends Runnable {
|
||||
BufferedImage parseUserSkin(BufferedImage image);
|
||||
|
||||
NativeImage func_195786_a(NativeImage image);
|
||||
|
||||
void skinAvailable();
|
||||
|
||||
@Override
|
||||
default void run() {
|
||||
this.skinAvailable();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
package net.minecraft.client.renderer;
|
||||
|
||||
import net.minecraft.util.ResourceLocation;
|
||||
|
||||
public class RenderType {
|
||||
// getEntityTranslucent
|
||||
public static RenderType func_228644_e_(ResourceLocation locationIn) {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,63 @@
|
||||
package net.minecraft.client.renderer.texture;
|
||||
|
||||
import java.io.InputStream;
|
||||
|
||||
/**
|
||||
* Empty stack for NativeImage
|
||||
*/
|
||||
public class NativeImage {
|
||||
public static NativeImage func_195713_a(InputStream inputStreamIn) {
|
||||
return null;
|
||||
}
|
||||
|
||||
public NativeImage(int p_i48122_1_, int p_i48122_2_, boolean p_i48122_3_) {
|
||||
}
|
||||
|
||||
/**
|
||||
* getWidth
|
||||
*/
|
||||
public int func_195702_a() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* getHeight
|
||||
*/
|
||||
public int func_195714_b() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* copyImage image
|
||||
*/
|
||||
public void func_195703_a(NativeImage p_195703_1_) {
|
||||
}
|
||||
|
||||
/**
|
||||
* fillAreaRGBA x0 y0 weight height rgba
|
||||
*/
|
||||
public void func_195715_a(int p_195715_1_, int p_195715_2_, int p_195715_3_, int p_195715_4_, int p_195715_5_) {
|
||||
}
|
||||
|
||||
/**
|
||||
* copyAreaRGBA x0 y0 dx dy weight height reversex reversey
|
||||
*/
|
||||
public void func_195699_a(int p_195699_1_, int p_195699_2_, int p_195699_3_, int p_195699_4_, int p_195699_5_, int p_195699_6_, boolean p_195699_7_, boolean p_195699_8_) {
|
||||
}
|
||||
|
||||
/**
|
||||
* getPixelRGBA x y
|
||||
*/
|
||||
public int func_195709_a(int p_195709_1_, int p_195709_2_) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* setPixelRGBA x y rgba
|
||||
*/
|
||||
public void func_195700_a(int p_195700_1_, int p_195700_2_, int p_195700_3_) {
|
||||
}
|
||||
|
||||
public void close() {
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,5 @@
|
||||
package net.minecraft.client.renderer.texture;
|
||||
|
||||
// exclude
|
||||
public interface Texture {
|
||||
}
|
||||
@@ -0,0 +1,8 @@
|
||||
package net.minecraft.client.resources;
|
||||
|
||||
import java.io.InputStream;
|
||||
|
||||
// this class shouldn't be created by ASM because of modlauncher issue.
|
||||
public interface IResource {
|
||||
InputStream getInputStream();
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
package net.minecraft.client.resources;
|
||||
|
||||
import java.io.IOException;
|
||||
|
||||
import net.minecraft.util.ResourceLocation;
|
||||
|
||||
// this class shouldn't be created by ASM because of modlauncher issue.
|
||||
public interface IResourceManager {
|
||||
IResource getResource(ResourceLocation location) throws IOException;
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
package net.minecraft.resources;
|
||||
|
||||
// exclude
|
||||
public interface IResource {
|
||||
|
||||
}
|
||||
@@ -0,0 +1,6 @@
|
||||
package net.minecraft.resources;
|
||||
|
||||
// exclude
|
||||
public interface IResourceManager {
|
||||
|
||||
}
|
||||
Reference in new issue
Block a user