diff --git a/1.8.8-mcp918/src/minecraft/idv/jlchntoz/CustomSkinLoader.java b/1.8.8-mcp918/src/minecraft/idv/jlchntoz/CustomSkinLoader.java new file mode 100644 index 0000000..995a0b9 --- /dev/null +++ b/1.8.8-mcp918/src/minecraft/idv/jlchntoz/CustomSkinLoader.java @@ -0,0 +1,361 @@ +package idv.jlchntoz; + +import net.minecraft.client.Minecraft; + +import java.io.*; +import java.math.BigInteger; +import java.net.*; +import java.nio.MappedByteBuffer; +import java.nio.channels.FileChannel; +import java.security.MessageDigest; +import java.security.NoSuchAlgorithmException; +import java.util.HashMap; +import java.util.logging.*; +import java.util.regex.*; + +/** + * Custom skin loader mod for Minecraft. + * + * @version 12th Revision 8th Subversion 2016.2.3 + * + * @author (C) Jeremy Lam [JLChnToZ] 2013 & Alexander Xia [xfl03] 2014-2016 + */ +public class CustomSkinLoader { + public final static String VERSION="12.8"; + + public final static String DefaultSkinURL = "http://skins.minecraft.net/MinecraftSkins/*.png"; + public final static String DefaultCloakURL = "http://skins.minecraft.net/MinecraftCloaks/*.png"; + + private final static Pattern newResPattern = Pattern.compile("^http://textures.minecraft.net/texture/(.*?)?(Skin|Cloak)=(.*?)$"), + newURLPattern = Pattern.compile("^http://skins.minecraft.net/Minecraft(Skin|Cloak)s/(.*?).png$"), + oldURLPattern = Pattern.compile("^http://s3.amazonaws.com/Minecraft(Skin|Cloak)s/(.*?).png$"), + optifineCapeURLPattern = Pattern.compile("^http://s.optifine.net/capes/(.*?).png$"); + + public final static File DATA_DIR=new File(Minecraft.getMinecraft().mcDataDir,"CustomSkinLoader"), + CACHE_DIR=new File(DATA_DIR,"caches"), + LOG_FILE=new File(DATA_DIR,"CustomSkinLoader.log"), + SKIN_URL_FILE=new File(DATA_DIR,"skinurls.txt"), + CAPE_URL_FILE=new File(DATA_DIR,"capeurls.txt"); + public final static MainLogger logger = getLogger(LOG_FILE); + + public final static String[] DEFAULT_SKIN_URLS={ + "http://skins.minecraft.net/MinecraftSkins/*.png", + "http://minecrack.fr.nf/mc/skinsminecrackd/*.png", + "http://www.skinme.cc/MinecraftSkins/*.png"}; + public final static String[] DEFAULT_CAPE_URLS={ + "http://skins.minecraft.net/MinecraftCloaks/*.png", + "http://s.optifine.net/capes/*.png", + "http://minecrack.fr.nf/mc/cloaksminecrackd/*.png", + "http://www.skinme.cc/MinecraftCloaks/*.png"}; + + private static String[] cloakURLs = null, skinURLs = null; + private HttpURLConnection C = null; + + //Entrance + public InputStream getPlayerSkinStream(String path) { + if(!DATA_DIR.exists()) + DATA_DIR.mkdir(); + if(!CACHE_DIR.exists()) + CACHE_DIR.mkdir(); + logger.info("Get a request: "+path); + if(path.contains("NOCSL"))//Not to use CSL to load, prepared for json api + return getStream(path, false); + Matcher m = newURLPattern.matcher(path); + if (!m.matches())//Is not new url + { + m = oldURLPattern.matcher(path);//May be old url + } + if (m.matches()) { + if (m.group(1).contains("Skin")) // Skin + return getPlayerSkinStream(false, m.group(2)); + else if (m.group(1).contains("Cloak")) // Cloak + return getPlayerSkinStream(true, m.group(2)); + }else{ + m = newResPattern.matcher(path); + if(m.matches()){ + if (m.group(2).contains("Skin")) // Skin + return getPlayerSkinStream(false, m.group(3)); + else if (m.group(2).contains("Cloak")) // Cloak + return getPlayerSkinStream(true, m.group(3)); + }else{ + m = optifineCapeURLPattern.matcher(path); + if(m.matches()){//Optifine Cape + logger.info("Ignore Optifine Cape."); + return null;//Not Load This + } + } + } + return getStream(path, false); // Neither skin nor cloak... + } + + public InputStream getPlayerSkinStream(Boolean isCloak, String playerName) { + if (skinURLs == null || cloakURLs == null || skinURLs.length <= 0 + || cloakURLs.length <= 0) + refreshSkinURL(); // If the list is blank or null, try to load again. + InputStream S=null; + + for (String l : isCloak ? cloakURLs : skinURLs) { + if(l==null||l.equalsIgnoreCase("")) + continue; + String loc = str_replace("*", playerName, l); + logger.log(Level.INFO, "Try to load " + (isCloak ? "cloak" : "skin") + " in " + loc); + S = getStream(loc, true); + + if (S == null){ + logger.log(Level.INFO, "No " + (isCloak ? "cloak" : "skin") + " found in " + loc); + }else{ + logger.info("Succeessfully load " + (isCloak ? "cloak" : "skin") + " in " + loc); + return S; + } + } + + logger.log(Level.INFO, "Try to load skin in default URL instead."); + return getStream(str_replace("*", playerName, isCloak ? DefaultCloakURL : DefaultSkinURL), true); + } + + private InputStream getStream(String URL, Boolean CheckPNG) { + boolean success=false; + File cacheFile=new File(CACHE_DIR,MD5(URL)); + boolean alreadyCached=false; + if(cacheFile.exists()&&cacheFile.length()>1){ + alreadyCached=true; + logger.info("Cache File Found (LastModified: "+cacheFile.lastModified()+")"); + } + try { + URL U = new URL(URL); + C = (HttpURLConnection) U.openConnection(); + C.setReadTimeout(15000); + C.setDoInput(true); + C.setDoOutput(false); + C.connect(); + logger.info("Response Code: "+C.getResponseCode()); + int respcode = C.getResponseCode() / 100; + if (respcode != 4 && respcode != 5) { // Successful to get skin. + logger.info("Successfully Get Resource (LastModified: "+cacheFile.lastModified()+")"); + if(alreadyCached && C.getLastModified()==cacheFile.lastModified()){ + logger.info("Not Modified!"); + return getStreamFromCache(cacheFile); + } + if(C.getContentLength()<=0){//Nothing to get + return null; + } + InputStream IS=new BufferedInputStream(C.getInputStream()); + if (!CheckPNG){ // If no need to check PNG header, just skip it. + success=true; + saveToCache(IS,cacheFile); + return IS; + } + //logger.info(C.getContentLength()+" "+IS.available()); + IS.mark(C.getContentLength()+10); + byte[] ib = new byte[4]; + IS.read(ib); + if (ib[1] == (byte) 'P' && ib[2] == (byte) 'N' && ib[3] == (byte) 'G') { // Check PNG Header if needed + IS.reset(); + success=true; + saveToCache(IS,cacheFile); + return IS; + } + } + } catch (Exception ex) { + success=false; + logger.log(Level.WARNING, ex.getMessage()); + if(alreadyCached) + return getStreamFromCache(cacheFile); + }finally{ + if(!success) + disconnect(); + } + return null; + } + private InputStream getStreamFromCache(File cacheFile) { + try{ + logger.info("Try load local cache in " + cacheFile.getAbsolutePath()); + InputStream in = new FileInputStream(cacheFile); + BufferedInputStream bis=new BufferedInputStream(in); + if(bis.available()<=0){ + logger.info("Cannot load local cache in " + cacheFile.getAbsolutePath()); + return null; + }else{ + logger.info("Successfully load cache in " + cacheFile.getAbsolutePath()); + return bis; + } + }catch(Exception e){ + logger.log(Level.WARNING, e.getMessage()); + return null; + } + } + private void saveToCache(InputStream is,File to){ + logger.info("Try save local cache to " + to.getAbsolutePath()); + FileOutputStream fs=null; + int times=0; + try{//Save to Local Skin File + if(to.exists()){ + to.delete(); + } + fs = new FileOutputStream(to); + int byteRead = 0; + byte[] buffer = new byte[1024]; + while (( byteRead = is.read(buffer)) != -1) { + times+=byteRead; + fs.write(buffer, 0, byteRead); + if(times>=C.getContentLength()){ + //logger.info(times+" "+C.getContentLength()); + break; + } + } + + if(to.length()>1){ + logger.info("Successfully save cache to " + to.getAbsolutePath()); + }else{ + to.delete(); + logger.info("Cannot save local cache to " + to.getAbsolutePath()); + } + }catch(Exception e){ + logger.warning(e.getMessage()); + }finally{ + try { + if(fs!=null) + fs.close(); + is.reset(); + logger.info("Cache size : "+is.available()); + if(to.exists()){ + to.setLastModified(C.getLastModified()); + logger.info("LastModified : "+to.lastModified()); + } + } catch (IOException e) { + logger.warning(e.getMessage()); + } + } + } + + public void disconnect() { + if (C != null) + C.disconnect(); + } + + private static void refreshSkinURL() { + try { + if(!SKIN_URL_FILE.exists()){ + logger.log(Level.INFO, "SKIN config not found, create a new one."); + SKIN_URL_FILE.createNewFile(); + } + if(!CAPE_URL_FILE.exists()){ + logger.log(Level.INFO, "CAPE config not found, create a new one."); + CAPE_URL_FILE.createNewFile(); + } + skinURLs = readAllLines(SKIN_URL_FILE); + cloakURLs = readAllLines(CAPE_URL_FILE); + } catch (Exception ex) { + logger.log(Level.WARNING, ex.getMessage()); + } finally { + if(skinURLs.length==0&&cloakURLs.length==0){ + logger.info("No skinURLs and cloak URLS found, try to init and use default settings."); + initSkinURL(); + refreshSkinURL(); + }else{ + logger.log(Level.INFO, "Skin URLs Refreshed. Skin count = " + + skinURLs.length + ", Cloak count = " + cloakURLs.length); + } + } + } + private static void initSkinURL(){ + //TODO Init URL List + skinURLs=DEFAULT_SKIN_URLS; + writeToFile(new File(DATA_DIR,"skinurls.txt"),parseArrayToText(skinURLs)); + cloakURLs=DEFAULT_CAPE_URLS; + writeToFile(new File(DATA_DIR,"capeurls.txt"),parseArrayToText(cloakURLs)); + } + + private static String[] readAllLines(File F) { + try { + logger.log(Level.INFO, "Config file: " + F.getAbsolutePath()); + if (F.length() <= 0) { + logger.log(Level.INFO, "Config file is blank, skipped."); + return new String[0]; + } else { + byte[] b = new byte[(int) F.length()]; + BufferedInputStream S = new BufferedInputStream( + new FileInputStream(F)); + S.read(b); + S.close(); + logger.log(Level.INFO, "Config file loaded."); + String[] re= str_replace("\r", "\n", + str_replace("\r\n", "\n", new String(b))).split("\n"); + for(int i=0;i=LOWEST_DISPLAY_LEVEL) + System.out.println(msg); + try { + writer.write("["); + writer.write(DATE_FORMAT.format(new Date())); + writer.write(" "); + writer.write(Thread.currentThread().getName()); + writer.write(" "); + writer.write(level.getName()); + writer.write("] "); + writer.write(msg); + writer.write("\r\n"); + writer.flush(); + } catch (Exception e) { + e.printStackTrace(); + } + } + public void info(String msg){ + log(Level.INFO,msg); + } + public void warning(String msg){ + log(Level.WARNING,msg); + } + public void warning(Exception e){ + log(Level.WARNING,"Exception occurs while running: "+e.getMessage()); + StackTraceElement[] stes=e.getStackTrace(); + for(StackTraceElement ste : stes){ + log(Level.WARNING,ste.toString()); + } + log(Level.WARNING,""); + } +} diff --git a/1.8.8-mcp918/src/minecraft/net/minecraft/client/renderer/ImageBufferDownload.java b/1.8.8-mcp918/src/minecraft/net/minecraft/client/renderer/ImageBufferDownload.java new file mode 100644 index 0000000..ad997aa --- /dev/null +++ b/1.8.8-mcp918/src/minecraft/net/minecraft/client/renderer/ImageBufferDownload.java @@ -0,0 +1,117 @@ +package net.minecraft.client.renderer; + +import java.awt.Graphics; +import java.awt.image.BufferedImage; +import java.awt.image.DataBufferInt; +import java.awt.image.ImageObserver; + +public class ImageBufferDownload implements IImageBuffer +{ + private int[] imageData; + private int imageWidth; + private int imageHeight; + + public BufferedImage parseUserSkin(BufferedImage image) + { + if (image == null) + { + return null; + } + else + { + int ratio=image.getWidth()/64; + this.imageWidth = 64 * ratio; + this.imageHeight = 64 * ratio; + BufferedImage var2 = new BufferedImage(this.imageWidth, this.imageHeight, 2); + Graphics var3 = var2.getGraphics(); + var3.drawImage(image, 0, 0, (ImageObserver)null); + + if (image.getHeight() == 32 * ratio) + { + var3.drawImage(var2, 24 * ratio, 48 * ratio, 20 * ratio, 52 * ratio, 4 * ratio, 16 * ratio, 8 * ratio, 20 * ratio, (ImageObserver)null); + var3.drawImage(var2, 28 * ratio, 48 * ratio, 24 * ratio, 52 * ratio, 8 * ratio, 16 * ratio, 12 * ratio, 20 * ratio, (ImageObserver)null); + var3.drawImage(var2, 20 * ratio, 52 * ratio, 16 * ratio, 64 * ratio, 8 * ratio, 20 * ratio, 12 * ratio, 32 * ratio, (ImageObserver)null); + var3.drawImage(var2, 24 * ratio, 52 * ratio, 20 * ratio, 64 * ratio, 4 * ratio, 20 * ratio, 8 * ratio, 32 * ratio, (ImageObserver)null); + var3.drawImage(var2, 28 * ratio, 52 * ratio, 24 * ratio, 64 * ratio, 0 * ratio, 20 * ratio, 4 * ratio, 32 * ratio, (ImageObserver)null); + var3.drawImage(var2, 32 * ratio, 52 * ratio, 28 * ratio, 64 * ratio, 12 * ratio, 20 * ratio, 16 * ratio, 32 * ratio, (ImageObserver)null); + var3.drawImage(var2, 40 * ratio, 48 * ratio, 36 * ratio, 52 * ratio, 44 * ratio, 16 * ratio, 48 * ratio, 20 * ratio, (ImageObserver)null); + var3.drawImage(var2, 44 * ratio, 48 * ratio, 40 * ratio, 52 * ratio, 48 * ratio, 16 * ratio, 52 * ratio, 20 * ratio, (ImageObserver)null); + var3.drawImage(var2, 36 * ratio, 52 * ratio, 32 * ratio, 64 * ratio, 48 * ratio, 20 * ratio, 52 * ratio, 32 * ratio, (ImageObserver)null); + var3.drawImage(var2, 40 * ratio, 52 * ratio, 36 * ratio, 64 * ratio, 44 * ratio, 20 * ratio, 48 * ratio, 32 * ratio, (ImageObserver)null); + var3.drawImage(var2, 44 * ratio, 52 * ratio, 40 * ratio, 64 * ratio, 40 * ratio, 20 * ratio, 44 * ratio, 32 * ratio, (ImageObserver)null); + var3.drawImage(var2, 48 * ratio, 52 * ratio, 44 * ratio, 64 * ratio, 52 * ratio, 20 * ratio, 56 * ratio, 32 * ratio, (ImageObserver)null); + } + + var3.dispose(); + this.imageData = ((DataBufferInt)var2.getRaster().getDataBuffer()).getData(); + this.setAreaOpaque(0, 0, 32 * ratio, 16 * ratio); + this.setAreaTransparent(32 * ratio, 0, 64 * ratio, 32 * ratio); + this.setAreaOpaque(0, 16 * ratio, 64 * ratio, 32 * ratio); + this.setAreaTransparent(0, 32 * ratio, 16 * ratio, 48 * ratio); + this.setAreaTransparent(16 * ratio, 32 * ratio, 40 * ratio, 48 * ratio); + this.setAreaTransparent(40 * ratio, 32 * ratio, 56 * ratio, 48 * ratio); + this.setAreaTransparent(0, 48 * ratio, 16 * ratio, 64 * ratio); + this.setAreaOpaque(16 * ratio, 48 * ratio, 48 * ratio, 64 * ratio); + this.setAreaTransparent(48 * ratio, 48 * ratio, 64 * ratio, 64 * ratio); + return var2; + } + } + + public void skinAvailable() + { + } + + /** + * Makes the given area of the image transparent if it was previously completely opaque (used to remove the outer + * layer of a skin around the head if it was saved all opaque; this would be redundant so it's assumed that the skin + * maker is just using an image editor without an alpha channel) + */ + private void setAreaTransparent(int p_78434_1_, int p_78434_2_, int p_78434_3_, int p_78434_4_) + { + if (!this.hasTransparency(p_78434_1_, p_78434_2_, p_78434_3_, p_78434_4_)) + { + for (int i = p_78434_1_; i < p_78434_3_; ++i) + { + for (int j = p_78434_2_; j < p_78434_4_; ++j) + { + this.imageData[i + j * this.imageWidth] &= 16777215; + } + } + } + } + + /** + * Makes the given area of the image opaque + */ + private void setAreaOpaque(int p_78433_1_, int p_78433_2_, int p_78433_3_, int p_78433_4_) + { + for (int i = p_78433_1_; i < p_78433_3_; ++i) + { + for (int j = p_78433_2_; j < p_78433_4_; ++j) + { + this.imageData[i + j * this.imageWidth] |= -16777216; + } + } + } + + /** + * Returns true if the given area of the image contains transparent pixels + */ + private boolean hasTransparency(int p_78435_1_, int p_78435_2_, int p_78435_3_, int p_78435_4_) + { + for (int i = p_78435_1_; i < p_78435_3_; ++i) + { + for (int j = p_78435_2_; j < p_78435_4_; ++j) + { + int k = this.imageData[i + j * this.imageWidth]; + + if ((k >> 24 & 255) < 128) + { + return true; + } + } + } + + return false; + } +} diff --git a/1.8.8-mcp918/src/minecraft/net/minecraft/client/renderer/ThreadDownloadImageData.java b/1.8.8-mcp918/src/minecraft/net/minecraft/client/renderer/ThreadDownloadImageData.java new file mode 100644 index 0000000..3304749 --- /dev/null +++ b/1.8.8-mcp918/src/minecraft/net/minecraft/client/renderer/ThreadDownloadImageData.java @@ -0,0 +1,148 @@ +package net.minecraft.client.renderer; + +import java.awt.image.BufferedImage; +import java.io.File; +import java.io.IOException; +import java.net.HttpURLConnection; +import java.net.URL; +import java.util.concurrent.atomic.AtomicInteger; +import javax.imageio.ImageIO; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.texture.SimpleTexture; +import net.minecraft.client.renderer.texture.TextureUtil; +import net.minecraft.client.resources.IResourceManager; +import net.minecraft.util.ResourceLocation; +import org.apache.commons.io.FileUtils; +import org.apache.logging.log4j.LogManager; +import org.apache.logging.log4j.Logger; + +import idv.jlchntoz.CustomSkinLoader; + +public class ThreadDownloadImageData extends SimpleTexture +{ + private static final Logger logger = LogManager.getLogger(); + private static final AtomicInteger threadDownloadCounter = new AtomicInteger(0); + private final File cacheFile; + private final String imageUrl; + private final IImageBuffer imageBuffer; + private BufferedImage bufferedImage; + private Thread imageThread; + private boolean textureUploaded; + + //For Optifine + public Boolean imageFound = null; + public boolean pipeline = false; + + public ThreadDownloadImageData(File cacheFileIn, String imageUrlIn, ResourceLocation textureResourceLocation, IImageBuffer imageBufferIn) + { + super(textureResourceLocation); + this.cacheFile = cacheFileIn; + this.imageUrl = imageUrlIn; + this.imageBuffer = imageBufferIn; + } + + private void checkTextureUploaded() + { + if (!this.textureUploaded) + { + if (this.bufferedImage != null) + { + if (this.textureLocation != null) + { + this.deleteGlTexture(); + } + + TextureUtil.uploadTextureImage(super.getGlTextureId(), this.bufferedImage); + this.textureUploaded = true; + } + } + } + + public int getGlTextureId() + { + this.checkTextureUploaded(); + return super.getGlTextureId(); + } + + public void setBufferedImage(BufferedImage bufferedImageIn) + { + this.bufferedImage = bufferedImageIn; + + if (this.imageBuffer != null) + { + this.imageBuffer.skinAvailable(); + } + } + + public void loadTexture(IResourceManager resourceManager) throws IOException + { + if (this.bufferedImage == null && this.textureLocation != null) + { + super.loadTexture(resourceManager); + } + + if (this.imageThread == null) + { + if (this.cacheFile != null && this.cacheFile.isFile()) + { + logger.info("Loading http texture from local cache ({})", new Object[] {this.cacheFile}); + + try + { + this.bufferedImage = ImageIO.read(this.cacheFile); + + if (this.imageBuffer != null) + { + this.setBufferedImage(this.imageBuffer.parseUserSkin(this.bufferedImage)); + } + } + catch (IOException ioexception) + { + logger.error((String)("Couldn\'t load skin " + this.cacheFile), (Throwable)ioexception); + this.loadTextureFromServer(); + } + } + else + { + this.loadTextureFromServer(); + } + } + } + + protected void loadTextureFromServer() + { + this.imageThread = new Thread("Texture Downloader #" + threadDownloadCounter.incrementAndGet()) + { + public void run() + { + CustomSkinLoader loader=new CustomSkinLoader(); + ThreadDownloadImageData.logger.info("Downloading http texture from {} to {}", new Object[] {ThreadDownloadImageData.this.imageUrl, ThreadDownloadImageData.this.cacheFile}); + + try + { + BufferedImage bufferedimage; + bufferedimage = TextureUtil.readBufferedImage(loader.getPlayerSkinStream(ThreadDownloadImageData.this.imageUrl)); + + if (ThreadDownloadImageData.this.imageBuffer != null) + { + bufferedimage = ThreadDownloadImageData.this.imageBuffer.parseUserSkin(bufferedimage); + } + + ThreadDownloadImageData.this.setBufferedImage(bufferedimage); + return; + } + catch (Exception exception) + { + ThreadDownloadImageData.logger.error((String)"Couldn\'t download http texture", (Throwable)exception); + return; + } + finally + { + loader.disconnect(); + } + } + }; + this.imageThread.setDaemon(true); + this.imageThread.start(); + } +} diff --git a/1.8.8-mcp918/src/minecraft/net/minecraft/client/resources/SkinManager.java b/1.8.8-mcp918/src/minecraft/net/minecraft/client/resources/SkinManager.java new file mode 100644 index 0000000..dc7f1e7 --- /dev/null +++ b/1.8.8-mcp918/src/minecraft/net/minecraft/client/resources/SkinManager.java @@ -0,0 +1,184 @@ +package net.minecraft.client.resources; + +import com.google.common.cache.CacheBuilder; +import com.google.common.cache.CacheLoader; +import com.google.common.cache.LoadingCache; +import com.google.common.collect.Maps; +import com.mojang.authlib.GameProfile; +import com.mojang.authlib.minecraft.InsecureTextureException; +import com.mojang.authlib.minecraft.MinecraftProfileTexture; +import com.mojang.authlib.minecraft.MinecraftSessionService; +import com.mojang.authlib.minecraft.MinecraftProfileTexture.Type; +import java.awt.image.BufferedImage; +import java.io.File; +import java.util.Map; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.LinkedBlockingQueue; +import java.util.concurrent.ThreadPoolExecutor; +import java.util.concurrent.TimeUnit; +import net.minecraft.client.Minecraft; +import net.minecraft.client.renderer.IImageBuffer; +import net.minecraft.client.renderer.ImageBufferDownload; +import net.minecraft.client.renderer.ThreadDownloadImageData; +import net.minecraft.client.renderer.texture.ITextureObject; +import net.minecraft.client.renderer.texture.TextureManager; +import net.minecraft.util.ResourceLocation; + +public class SkinManager +{ + private static final ExecutorService THREAD_POOL = new ThreadPoolExecutor(0, 2, 1L, TimeUnit.MINUTES, new LinkedBlockingQueue()); + private final TextureManager textureManager; + private final File skinCacheDir; + private final MinecraftSessionService sessionService; + private final LoadingCache> skinCacheLoader; + + public SkinManager(TextureManager textureManagerInstance, File skinCacheDirectory, MinecraftSessionService sessionService) + { + this.textureManager = textureManagerInstance; + this.skinCacheDir = skinCacheDirectory; + this.sessionService = sessionService; + this.skinCacheLoader = CacheBuilder.newBuilder().expireAfterAccess(15L, TimeUnit.SECONDS).>build(new CacheLoader>() + { + public Map load(GameProfile p_load_1_) throws Exception + { + return Minecraft.getMinecraft().getSessionService().getTextures(p_load_1_, false); + } + }); + } + + /** + * Used in the Skull renderer to fetch a skin. May download the skin if it's not in the cache + */ + public ResourceLocation loadSkin(MinecraftProfileTexture profileTexture, Type p_152792_2_) + { + return this.loadSkin(profileTexture, p_152792_2_, (SkinManager.SkinAvailableCallback)null); + } + + /** + * May download the skin if its not in the cache, can be passed a SkinManager#SkinAvailableCallback for handling + */ + public ResourceLocation loadSkin(final MinecraftProfileTexture profileTexture, final Type p_152789_2_, final SkinManager.SkinAvailableCallback skinAvailableCallback) + { + final ResourceLocation resourcelocation = new ResourceLocation(p_152789_2_.name() + "/" + profileTexture.getHash()); + /*Remove cache + ITextureObject itextureobject = this.textureManager.getTexture(resourcelocation); + + if (itextureobject != null) + { + if (skinAvailableCallback != null) + { + skinAvailableCallback.skinAvailable(p_152789_2_, resourcelocation, profileTexture); + } + } + else + {*/ + File file1 = new File(this.skinCacheDir, profileTexture.getHash().length() > 2 ? profileTexture.getHash().substring(0, 2) : "xx"); + File file2 = new File(file1, profileTexture.getHash()); + final IImageBuffer iimagebuffer = p_152789_2_ == Type.SKIN ? new ImageBufferDownload() : null; + ThreadDownloadImageData threaddownloadimagedata = new ThreadDownloadImageData(file2, profileTexture.getUrl(), DefaultPlayerSkin.getDefaultSkinLegacy(), new IImageBuffer() + { + public BufferedImage parseUserSkin(BufferedImage image) + { + if (iimagebuffer != null) + { + image = iimagebuffer.parseUserSkin(image); + } + + return image; + } + public void skinAvailable() + { + if (iimagebuffer != null) + { + iimagebuffer.skinAvailable(); + } + + if (skinAvailableCallback != null) + { + skinAvailableCallback.skinAvailable(p_152789_2_, resourcelocation, profileTexture); + } + } + }); + this.textureManager.loadTexture(resourcelocation, threaddownloadimagedata); + //} + + return resourcelocation; + } + + public void loadProfileTextures(final GameProfile profile, final SkinManager.SkinAvailableCallback skinAvailableCallback, final boolean requireSecure) + { + THREAD_POOL.submit(new Runnable() + { + public void run() + { + final Map map = Maps.newHashMap(); + + try + { + map.putAll(SkinManager.this.sessionService.getTextures(profile, requireSecure)); + } + catch (InsecureTextureException var3) + { + ; + } + + if (map.isEmpty() && profile.getId().equals(Minecraft.getMinecraft().getSession().getProfile().getId())) + { + profile.getProperties().clear(); + profile.getProperties().putAll(Minecraft.getMinecraft().func_181037_M()); + map.putAll(SkinManager.this.sessionService.getTextures(profile, false)); + } + //CustomSkinLoader Begin + Map var2 = Maps.newHashMap(); + if (map.containsKey(Type.SKIN)){ + MinecraftProfileTexture var3=((MinecraftProfileTexture)map.get(Type.SKIN)); + String var4=var3.getMetadata("model"); + Map var5 = null; + if(var4!=null){ + var5 = Maps.newHashMap(); + var5.put("model", var4); + } + var2.put(Type.SKIN, new MinecraftProfileTexture(var3.getUrl()+"?Skin="+profile.getName(),var5)); + }else{ + Map var5 = Maps.newHashMap(); + //var5.put("model", "slim"); + var2.put(Type.SKIN,new MinecraftProfileTexture( "http://skins.minecraft.net/MinecraftSkins/"+profile.getName()+".png",var5)); + } + if (map.containsKey(Type.CAPE)){ + var2.put(Type.CAPE, new MinecraftProfileTexture(((MinecraftProfileTexture)map.get(Type.CAPE)).getUrl()+"?Cloak="+profile.getName(),null)); + }else{ + var2.put(Type.CAPE,new MinecraftProfileTexture( "http://skins.minecraft.net/MinecraftCloaks/"+profile.getName()+".png",null)); + } + map.clear(); + map.putAll(var2); + //CustomSkinLoader End + + Minecraft.getMinecraft().addScheduledTask(new Runnable() + { + public void run() + { + if (map.containsKey(Type.SKIN)) + { + SkinManager.this.loadSkin((MinecraftProfileTexture)map.get(Type.SKIN), Type.SKIN, skinAvailableCallback); + } + + if (map.containsKey(Type.CAPE)) + { + SkinManager.this.loadSkin((MinecraftProfileTexture)map.get(Type.CAPE), Type.CAPE, skinAvailableCallback); + } + } + }); + } + }); + } + + public Map loadSkinFromCache(GameProfile profile) + { + return (Map)this.skinCacheLoader.getUnchecked(profile); + } + + public interface SkinAvailableCallback + { + void skinAvailable(Type p_180521_1_, ResourceLocation location, MinecraftProfileTexture profileTexture); + } +}