Curso de Reflection NMS + Varias APIS FREE

RUSHyoutuber · Setembro 14, 2018

Como não achei uma área correta pra postar isso resolvi postar aqui em tutoriais mesmo.

MEU MINI-CURSO DE REFLECTION:

Este tópico contem os seguintes códigos:

* API Para enviar mensagens ActionBar

* API Para enviar titles

* API Para pegar o ping do player

* API Para pegar a linguagem do minecraft do player

* API Para setar/pegar o modo GOD do player (da maneira correta)

* API Para setar atributos especiais em um item

* API Para tablist

* API Para crashar players

PS: TODAS AS APIS FUNCIONAM PERFEITAMENTE EM TODAS AS VERSÕES DESDE 1.5 ATÉ 1.13.*

(é claro que o TitleAPI não vai funcionar na 1.5 por causa que não existe title na 1.5 mas vocês entenderam né....)

Bom primeiramente você ira precisar de uma classe chamada ReflectionUtils com alguns métodos uteis para nós trabalharmos:

Spoiler


package rush.utils;

import java.lang.reflect.InvocationTargetException;

import org.bukkit.Bukkit;
import org.bukkit.entity.Player;

/**
 * @author Mior
 * @version 1.0
 * @category utils
 */

public class ReflectionUtils {
	
   	public static Class<?> getNMSClass(String name) {
   		String version = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
   		try {
   			return Class.forName("net.minecraft.server." + version + "." + name);
   		} catch (ClassNotFoundException | ArrayIndexOutOfBoundsException e) {
   			return null;
   		}
   	}
   	
   	public static Class<?> getOBClass(String name) {
   		String version = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
   		try {
   			return Class.forName("org.bukkit.craftbukkit." + version + "." + name);
   		} catch (ClassNotFoundException | ArrayIndexOutOfBoundsException e) {
   			return null;
   		}
   	}
   	
   	public static void sendPacket(Player player, Object packet) {
   		try {
   			Object entityPlayer = player.getClass().getMethod("getHandle").invoke(player);
   			Object playerConnection = entityPlayer.getClass().getField("playerConnection").get(entityPlayer);
   			playerConnection.getClass().getMethod("sendPacket", getNMSClass("Packet")).invoke(playerConnection, packet);
   		} catch (SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | NoSuchMethodException | NoSuchFieldException e) {
   			e.printStackTrace();
   		}
   	}
}

Logo após isso você precisaria criar uma Enum Version e precisara também criar um método no onEnable para pegar a version do servidor então vamos lá!

Spoiler


package rush.entidades;

public enum Version {

	v1_13,
	v1_12,
	v1_11,
	v1_10,
	v1_9,
	v1_8,
	v1_7,
	v1_6,
	v1_5,
	DESCONHECIDA;
	
}

Spoiler


package rush;

import org.bukkit.Bukkit;
import org.bukkit.event.Listener;
import org.bukkit.plugin.java.JavaPlugin;

import rush.entidades.Version;

public class Main extends JavaPlugin implements Listener {

	private static Version version;

	@Override
	public void onEnable() {
		checkServerVersion();
	}

	private Version checkServerVersion() {
		String ver = Bukkit.getVersion();

		if (ver.contains("1.13"))
			return Version.v1_13;
		else if (ver.contains("1.12"))
			return Version.v1_12;
		else if (ver.contains("1.11"))
			return Version.v1_11;
		else if (ver.contains("1.10"))
			return Version.v1_10;
		else if (ver.contains("1.9"))
			return Version.v1_9;
		else if (ver.contains("1.8"))
			return Version.v1_8;
		else if (ver.contains("1.7"))
			return Version.v1_7;
		else if (ver.contains("1.6"))
			return Version.v1_6;
		else if (ver.contains("1.5"))
			return Version.v1_5;
		else
			return Version.DESCONHECIDA;
	}

	public static Version getVersion() {
		return version;
	}


}

Logo após isso você precisara criar um método para carregar as APIS porque nós iremos deixar as Classes e métodos já prontos ou seja cacheados então eu criei para min uma classe chamada APIS e nela eu criei o método load()

Esse método sera chamada no onEnable para "ligar" ou "carregar" as APIS e otimizar um pouco o código

Spoiler


package rush.apis;

public class APIS {

	public static void load() 
	{
		try 
		{
			CrashAPI.load();
			TablistAPI.load();
			ActionBarAPI.load();
			TitleAPI.load();	
			ItemAPI.load();
		} 
		catch (Exception e) {}
		
	}
	
}

Logo após isso esta tudo pronto! Basta aproveitar as APIS! Lembrando que elas funcionam da 1.5 até a 1.13!

* ActionBarAPI

Spoiler


package rush.apis;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import org.bukkit.entity.Player;

import rush.Main;
import rush.entidades.Version;
import rush.utils.ReflectionUtils;

public class ActionBarAPI {
    
	private static Method a;
	private static Object typeMessage;
	private static Constructor<?> chatConstructor;
	
	public static void sendActionBar(Player player, String message) {
		try {
			Object chatMessage = a.invoke(null, "{\"text\":\"" + message + "\"}");
		    Object packet = chatConstructor.newInstance(chatMessage, typeMessage);
		    ReflectionUtils.sendPacket(player, packet);
		} catch (SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | InstantiationException | NullPointerException e) {
			e.printStackTrace();
		}
	}
	
	static void load() {
		try 
		{
			Class<?> typeMessageClass;
			Class<?> icbc = ReflectionUtils.getNMSClass("IChatBaseComponent");
			Class<?> ppoc = ReflectionUtils.getNMSClass("PacketPlayOutChat");
			
			if (icbc.getDeclaredClasses().length > 0) {
				a = icbc.getDeclaredClasses()[0].getMethod("a", String.class);
			} else {
				a = ReflectionUtils.getNMSClass("ChatSerializer").getMethod("a", String.class);
			}
			
			if (Main.getVersion() == Version.v1_12 || Main.getVersion()  == Version.v1_13) {
				typeMessageClass = ReflectionUtils.getNMSClass("ChatMessageType");
				typeMessage = typeMessageClass.getEnumConstants()[2];
			} else {
				typeMessageClass = byte.class;
				typeMessage = (byte)2;
			}
			
			chatConstructor = ppoc.getConstructor(icbc,  typeMessageClass);	
		}
		catch (SecurityException | IllegalArgumentException | NoSuchMethodException | NullPointerException e) {}
	}
}

* CrashAPI

Spoiler


package rush.apis;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Collections;
import java.util.List;

import org.bukkit.Bukkit;
import org.bukkit.entity.Player;

import rush.Main;
import rush.entidades.Version;
import rush.utils.ReflectionUtils;

public class CrashAPI {
	
	private static Object packet;
	
	public static void crashPlayer(Player player) {
		try {
		    ReflectionUtils.sendPacket(player, packet);
		} catch (SecurityException | IllegalArgumentException | NullPointerException e) {
			Bukkit.getConsoleSender().sendMessage("§c[System] Erro ao tentar crashar o player " + player.getName() + "!");
		}
	}
	
	static void load() {
		try
		{
			Object Vec3D;
			Class<?> explosionClass;
			Class<?> vectorClass = ReflectionUtils.getNMSClass("Vec3D");
			
			if (Main.getVersion() == Version.v1_5 || Main.getVersion() == Version.v1_6) {
				explosionClass = ReflectionUtils.getNMSClass("Packet60Explosion");
			} else {
				explosionClass = ReflectionUtils.getNMSClass("PacketPlayOutExplosion");
			}
			
			if (Main.getVersion() == Version.v1_5 || Main.getVersion() == Version.v1_6 || Main.getVersion() == Version.v1_7) {
			    Method Vector3dConstructor = vectorClass.getMethod("a", double.class, double.class, double.class);
				Vec3D = Vector3dConstructor.invoke(null, Double.MAX_VALUE, Double.MAX_VALUE, Double.MAX_VALUE);
			} else {
			    Constructor<?> Vector3dConstructor = vectorClass.getConstructor(double.class, double.class, double.class);
			    Vec3D = Vector3dConstructor.newInstance(Double.MAX_VALUE, Double.MAX_VALUE, Double.MAX_VALUE);
			}
			
			Constructor<?> explosionConstructor = explosionClass.getConstructor(double.class, double.class, double.class, float.class, List.class, vectorClass);
			packet = explosionConstructor.newInstance(Double.MAX_VALUE, Double.MAX_VALUE, Double.MAX_VALUE, Float.MAX_VALUE, Collections.emptyList(), Vec3D);
		} 
		catch (SecurityException | IllegalArgumentException | NoSuchMethodException | IllegalAccessException | InvocationTargetException | InstantiationException | NullPointerException e) {}
	}
}

* GodModeAPI

Spoiler


package rush.apis;

import java.lang.reflect.InvocationTargetException;

import org.bukkit.entity.Player;

public class GodModeAPI {
	
	public static void setGodMode(Player player, boolean enabled) {
		try {
			Object entityPlayer = player.getClass().getMethod("getHandle").invoke(player);
			Object abilities = entityPlayer.getClass().getField("abilities").get(entityPlayer);
			abilities.getClass().getField("isInvulnerable").set(abilities, enabled);
		} catch (IllegalArgumentException | IllegalAccessException | NoSuchFieldException | SecurityException | InvocationTargetException | NoSuchMethodException e) {
			e.printStackTrace();
		}
	}

	public static boolean getGodMode(Player player) {
		try {
			Object entityPlayer = player.getClass().getMethod("getHandle").invoke(player);
			Object abilities = entityPlayer.getClass().getField("abilities").get(entityPlayer);
			return abilities.getClass().getField("isInvulnerable").getBoolean(abilities);
		} catch (IllegalArgumentException | IllegalAccessException | NoSuchFieldException | SecurityException | InvocationTargetException | NoSuchMethodException e) {
			e.printStackTrace();
		}
		return false;
	}
}

* ItemAPI - Não foi adaptada para versões 1.6 e 1.5 (quem tiver vontade de adaptar é extremamente simples e facil não fiz pq não quis msm...)

Spoiler


package rush.apis;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.Random;

import org.bukkit.inventory.ItemStack;

import rush.utils.ReflectionUtils;

public class ItemAPI {

	private static Class<?> CraftItemStackClass;
	private static Class<?> NBTTagCompoundClass;
	private static Class<?> NBTBaseClass;
	private static Class<?> NBTTagListClass;
	private static Class<?> NBTTagStringClass;
	private static Class<?> NBTTagIntClass;
	private static Class<?> NBTTagDoubleClass;
	private static Class<?> ItemStackClass;
	private static Method asNMSCopy;
	private static Method asCraftMirror;
	private static Method setBoolean;
	private static Method setNBTTagCompound;
	private static Method hasNBTTagCompound;
	private static Method getNBTTagCompound;
	private static Method getNBTList;
	private static Method getNBTBase;
	private static Method addNBTBaseTag;
	private static Method setNBTBaseCompound;
	private static Method hasTag;
	private static Method createTag;
	
	public static ItemStack setAttributeNBT(ItemStack item, String attribute, double value, int operation) {
		int least = new Random().nextInt(8192);
		int most = new Random().nextInt(8192);
		try	{
			
			Object NBTTagCompound;
			Object CraftItemStack = asNMSCopy.invoke(null, item);
			boolean hasNBT = (boolean) hasNBTTagCompound.invoke(CraftItemStack);
			if (hasNBT) {
				NBTTagCompound = getNBTTagCompound.invoke(CraftItemStack);
			} else {
				NBTTagCompound = NBTTagCompoundClass.newInstance();
			}
			
			Object AttributeModifiers;
			Object Modifier = NBTTagCompoundClass.newInstance();
			boolean hasAttribute = (boolean) hasTag.invoke(NBTTagCompound, "AttributeModifiers");
			if (hasAttribute) {
				AttributeModifiers = getNBTList.invoke(NBTTagCompound, "AttributeModifiers", 10);
			} else {
				AttributeModifiers = NBTTagListClass.newInstance();
			}
			
			Object AttributeName = createTag.invoke(null, (byte) 8);
			Field fieldAttributeName = NBTTagStringClass.getDeclaredField("data");
			fieldAttributeName.setAccessible(true);
			fieldAttributeName.set(AttributeName, attribute);
			
			Object Name = createTag.invoke(null, (byte) 8);
			Field fieldName = NBTTagStringClass.getDeclaredField("data");
			fieldName.setAccessible(true);
			fieldName.set(Name, attribute);
			
			Object Amount = createTag.invoke(null, (byte) 6);
			Field fieldAmount = NBTTagDoubleClass.getDeclaredField("data");
			fieldAmount.setAccessible(true);
			fieldAmount.set(Amount, value);
			
			Object Operation = createTag.invoke(null, (byte) 3);
			Field fieldOperation = NBTTagIntClass.getDeclaredField("data");
			fieldOperation.setAccessible(true);
			fieldOperation.set(Operation, operation);
			
			Object UUIDLeast = createTag.invoke(null, (byte) 3);
			Field fieldUUIDLeast = NBTTagIntClass.getDeclaredField("data");
			fieldUUIDLeast.setAccessible(true);
			fieldUUIDLeast.set(UUIDLeast, least);
			
			Object UUIDMost = createTag.invoke(null, (byte) 3);
			Field fieldUUIDMost = NBTTagIntClass.getDeclaredField("data");
			fieldUUIDMost.setAccessible(true);
			fieldUUIDMost.set(UUIDMost, most);
			
			setNBTBaseCompound.invoke(Modifier, "AttributeName", AttributeName);
			setNBTBaseCompound.invoke(Modifier, "Name", Name);
			setNBTBaseCompound.invoke(Modifier, "Amount", Amount);
			setNBTBaseCompound.invoke(Modifier, "Operation", Operation);
			setNBTBaseCompound.invoke(Modifier, "UUIDLeast", UUIDLeast);
			setNBTBaseCompound.invoke(Modifier, "UUIDMost", UUIDMost);

			Object NBTBase = getNBTBase.invoke(Modifier);
			addNBTBaseTag.invoke(AttributeModifiers, NBTBase);
			setNBTBaseCompound.invoke(NBTTagCompound, "AttributeModifiers", AttributeModifiers);
			setNBTTagCompound.invoke(CraftItemStack, NBTTagCompound);
			
			return (ItemStack) asCraftMirror.invoke(null, CraftItemStack);
		} catch (NullPointerException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | InstantiationException | NoSuchFieldException e) {
			e.printStackTrace();
		}
		return null;
	}
	
	public static ItemStack setUnbreakable(ItemStack item, boolean bool) {
		if (item != null && item.getType().getMaxDurability() != 0 && item.getDurability() != 0) {
			item.setDurability((short)0);
		}
		try	{
			Object NBTTagCompound;
			Object CraftItemStack = asNMSCopy.invoke(null, item);
			boolean hasNBT = (boolean) hasNBTTagCompound.invoke(CraftItemStack);
			if (hasNBT) {
				NBTTagCompound = getNBTTagCompound.invoke(CraftItemStack);
			} else {
				NBTTagCompound = NBTTagCompoundClass.newInstance();
			}
			setBoolean.invoke(NBTTagCompound, "Unbreakable", true);
			setNBTTagCompound.invoke(CraftItemStack, NBTTagCompound);
			return (ItemStack) asCraftMirror.invoke(null, CraftItemStack);
		} catch (NullPointerException | SecurityException | IllegalAccessException | IllegalArgumentException | InvocationTargetException | InstantiationException e) {
			e.printStackTrace();
		}
		return null;
	}
	
	static void load() {
		try 
		{
			CraftItemStackClass = ReflectionUtils.getOBClass("inventory.CraftItemStack");
			NBTTagCompoundClass = ReflectionUtils.getNMSClass("NBTTagCompound");
			NBTBaseClass = ReflectionUtils.getNMSClass("NBTBase");
			NBTTagListClass = ReflectionUtils.getNMSClass("NBTTagList");
			NBTTagStringClass = ReflectionUtils.getNMSClass("NBTTagString");
			NBTTagIntClass = ReflectionUtils.getNMSClass("NBTTagInt");
			NBTTagDoubleClass = ReflectionUtils.getNMSClass("NBTTagDouble");
			ItemStackClass = ReflectionUtils.getNMSClass("ItemStack");
			asNMSCopy = CraftItemStackClass.getDeclaredMethod("asNMSCopy", ItemStack.class);
			asCraftMirror = CraftItemStackClass.getDeclaredMethod("asCraftMirror", ItemStackClass);
			setBoolean = NBTTagCompoundClass.getDeclaredMethod("setBoolean", String.class, boolean.class);
			setNBTTagCompound = ItemStackClass.getDeclaredMethod("setTag", NBTTagCompoundClass);
			hasNBTTagCompound = ItemStackClass.getDeclaredMethod("hasTag");
			getNBTTagCompound = ItemStackClass.getDeclaredMethod("getTag");
			getNBTList = NBTTagCompoundClass.getDeclaredMethod("getList", String.class, int.class);
			getNBTBase = NBTTagCompoundClass.getDeclaredMethod("clone");
			addNBTBaseTag = NBTTagListClass.getDeclaredMethod("add", NBTBaseClass);
			setNBTBaseCompound = NBTTagCompoundClass.getDeclaredMethod("set", String.class, NBTBaseClass);
			hasTag = NBTTagCompoundClass.getDeclaredMethod("hasKey", String.class);
			createTag = NBTBaseClass.getDeclaredMethod("createTag", byte.class);
			createTag.setAccessible(true);
		}
		catch (SecurityException | IllegalArgumentException | NullPointerException | NoSuchMethodException e) {}
	}
}


enum Attribute {
	
    ARMOR("generic.armor"), // Funcional apenas da 1.9 pra cima
    ARMORTOUGHNESS("generic.armorToughness"), // Funcional apenas da 1.9 pra cima
	DAMAGE("generic.attackDamage"),
	KNOCKBACKRESISTANCE("generic.knockbackResistance"),
	FOLLOWRANGE("generic.followRange"),
	MAXHEALTH("generic.maxHealth"),
	SPEED("generic.movementSpeed");
	
	private String attribute;
	
	Attribute(String attribute) {
		this.attribute = attribute;
	}
	
	public String getAttribute() {
		return this.attribute;
	}
}

* Ping API

Spoiler


package rush.apis;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;

import org.bukkit.entity.Player;

public class PingAPI {

	public static String getPlayerPing(Player player) {
		try {
			Object entityPlayer = player.getClass().getMethod("getHandle").invoke(player);
			Field ping = entityPlayer.getClass().getField("ping");
			return String.valueOf(ping.get(entityPlayer));
		} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException | NoSuchMethodException	| SecurityException | NoSuchFieldException e) {
			return "§cIndisponivel";
		}
	}
}

* TablistAPI

Spoiler


package rush.apis;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import org.bukkit.entity.Player;

import rush.utils.ReflectionUtils;

public class TablistAPI {	
	
	private static Class<?> ppop;
	private static Method a;
	private static int h;
	private static int f;
	
	public static void sendTabList(Player player, String header, String footer) {
		try {
			
			Object tabHeader = a.invoke(null, "{\"text\":\"" + header + "\"}");
			Object tabFooter = a.invoke(null, "{\"text\":\"" + footer + "\"}");
			
			Object packet = ppop.newInstance();
			
			Field headerField = ppop.getDeclaredFields()[h];
			headerField.setAccessible(true);
			headerField.set(packet, tabHeader);
	        
			Field footerField = ppop.getDeclaredFields()[f];
			footerField.setAccessible(true);
			footerField.set(packet, tabFooter);	
			
			ReflectionUtils.sendPacket(player, packet);
			
		} catch (IllegalArgumentException | SecurityException | IllegalAccessException | InvocationTargetException | InstantiationException | NullPointerException e) {
			e.printStackTrace();
		}
	}
	
	static void load() {
		try 
		{
			Class<?> icbc = ReflectionUtils.getNMSClass("IChatBaseComponent");
			ppop = ReflectionUtils.getNMSClass("PacketPlayOutPlayerListHeaderFooter");
			
			if (icbc.getDeclaredClasses().length > 0) {
				a = icbc.getDeclaredClasses()[0].getMethod("a", String.class);
			} else {
				a = ReflectionUtils.getNMSClass("ChatSerializer").getMethod("a", String.class);
			}
			
			if (ppop.getDeclaredFields().length > 2) {
				h = 2;
				f = 3;
			} else {
				h = 0;
				f = 1;
			}
		} 
		catch (SecurityException | IllegalArgumentException | NoSuchMethodException | NullPointerException e) {}
	}	
}

* TitleAPI

Spoiler


package rush.apis;

import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

import org.bukkit.Bukkit;
import org.bukkit.entity.Player;

import rush.utils.ReflectionUtils;

public class TitleAPI {
	
	private static Method a;
	private static Object enumTIMES;
	private static Object enumTITLE;
	private static Object enumSUBTITLE;
	private static Constructor<?> timeTitleConstructor;
	private static Constructor<?> textTitleConstructor;
	
	public static void sendTitle(Player player, Integer fadeIn, Integer stay, Integer fadeOut, String title, String subtitle) {
		try {

			Object chatTitle = a.invoke(null, "{\"text\":\"" + title + "\"}");
			Object chatSubtitle = a.invoke(null,"{\"text\":\"" + subtitle + "\"}");
			
			Object timeTitlePacket = timeTitleConstructor.newInstance(enumTIMES, null, fadeIn, stay, fadeOut);
			ReflectionUtils.sendPacket(player, timeTitlePacket);

			Object titlePacket = textTitleConstructor.newInstance(enumTITLE, chatTitle);
			ReflectionUtils.sendPacket(player, titlePacket);

			Object subtitlePacket = textTitleConstructor.newInstance(enumSUBTITLE, chatSubtitle);
			ReflectionUtils.sendPacket(player, subtitlePacket);

		} catch (IllegalArgumentException | IllegalAccessException | SecurityException | InvocationTargetException | InstantiationException | NullPointerException e) {
			e.printStackTrace();
		}
	}
	
	static void load() {
		try 
		{
			Class<?> icbc = ReflectionUtils.getNMSClass("IChatBaseComponent");
			Class<?> ppot = ReflectionUtils.getNMSClass("PacketPlayOutTitle");
			Class<?> enumClass;

			if (ppot.getDeclaredClasses().length > 0) {
				enumClass = ppot.getDeclaredClasses()[0];
			} else {
				enumClass = ReflectionUtils.getNMSClass("EnumTitleAction");
			}
			
			if (icbc.getDeclaredClasses().length > 0) {
				a = icbc.getDeclaredClasses()[0].getMethod("a", String.class);
			} else {
				a = ReflectionUtils.getNMSClass("ChatSerializer").getMethod("a", String.class);
			}
			
			enumTIMES = enumClass.getField("TIMES").get(null);
			enumTITLE = enumClass.getField("TITLE").get(null);
			enumSUBTITLE = enumClass.getField("SUBTITLE").get(null);
			timeTitleConstructor = ppot.getConstructor(enumClass, icbc, int.class, int.class, int.class);
			textTitleConstructor = ppot.getConstructor(enumClass, icbc);
		}
		catch (SecurityException | IllegalArgumentException | NoSuchMethodException | IllegalAccessException | NoSuchFieldException | NullPointerException e) {}
	}
}

* LocaleAPI (pegar linguagem do minecraft do player) // Funcional a penas da 1.8 pra cima

Spoiler


	
	public static String getLocale(Player player) {
		try {
			Object entityPlayer = player.getClass().getMethod("getHandle").invoke(player);
			Field ping = entityPlayer.getClass().getField("locale");
			return String.valueOf(ping.get(entityPlayer));
		} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException | NoSuchMethodException	| SecurityException | NoSuchFieldException e) {
			return "§cIndisponivel";
		}
	}

BRINDE:

* ComputerMemoryAPI (API Para pegar a quantia de memória que tem no computador)

Spoiler


	public static String bytesToLegibleValue(long bytes) {
		if (bytes < 1024 * 1024)
			return String.format("%.2f KB", bytes);
		else if (bytes < Math.pow(2, 20) * 1024)
			return String.format("%.2f MB", bytes / Math.pow(2, 20));
		else if (bytes < Math.pow(2, 30) * 1024 )
			return String.format("%.2f GB", bytes / Math.pow(2, 30));
		else if (bytes < Math.pow(2, 40) * 1024)
			return String.format("%.2f TB", bytes / Math.pow(2, 40));
		else
			return "N/A (1TB?)";
	}
	
	public static long getFreeMemoryComputer() {
		try {
			OperatingSystemMXBean system = ManagementFactory.getOperatingSystemMXBean();
			Method getFreeMemory = system.getClass().getMethod("getFreePhysicalMemorySize");
			getFreeMemory.setAccessible(true);
			return (long) getFreeMemory.invoke(system);
		} catch (Exception e) {
			return -1;
		}
	}
	
	public static long getTotalMemoryComputer() {
		try {
			OperatingSystemMXBean system = ManagementFactory.getOperatingSystemMXBean();
			Method getTotalMemory = system.getClass().getMethod("getTotalPhysicalMemorySize");
			getTotalMemory.setAccessible(true);
			return (long) getTotalMemory.invoke(system);
		} catch (Exception e) {
			return -1;
		}
	}

	// Após pegar a quantidade de memória do PC você pode converter o número de bytes da memória para um número legivel
   // Usando o método acima

iHuck · Setembro 14, 2018

Parabéns, parece que os vídeos estão bem feitos, pelo que eu vi aqui no inicio!

RUSHyoutuber · Setembro 14, 2018

59 minutos atrás, iHuck disse:

Parabéns, parece que os vídeos estão bem feitos, pelo que eu vi aqui no inicio!

vlw mano

Setembro 14, 2018

Qualidade é de mais de 8 mil!!

Parabéns, talvez eu use, thank you por existir.

HeyStone · Setembro 15, 2018

boa rush!

RUSHyoutuber · Setembro 16, 2018

Em 14/09/2018 em 19:41, dgcmf disse:

Qualidade é de mais de 8 mil!!

Parabéns, talvez eu use, thank you por existir.

vlw pelo apoio e pelo suporte

Em 14/09/2018 em 23:27, HeyStone disse:

boa rush!

vlw mano

RUSHyoutuber · Novembro 11, 2018

Adicionei também uma nova API de renderização ta la no gitHub

landermas · Dezembro 28, 2019

Isso funciona nas versões mais atuais ?

RUSHyoutuber · Janeiro 2, 2020

Em 28/12/2019 em 18:18, landermas disse:

Isso funciona nas versões mais atuais ?

Sim. Todas as APIs estão atualizadas pra 1.15 e 1.14.

Se quiser pode conferir na Source do System, estou utilizando todas essas APIs no System e esta tudo funcionando perfeitamente na 1.15.

Entrar

Curso de Reflection NMS + Varias APIS FREE

Posts Recomendados

RUSHyoutuber

Link para o comentário

Compartilhar em outros sites

iHuck

Link para o comentário

Compartilhar em outros sites

RUSHyoutuber

Link para o comentário

Compartilhar em outros sites

Visitante

Link para o comentário

Compartilhar em outros sites

HeyStone

Link para o comentário

Compartilhar em outros sites

RUSHyoutuber

Link para o comentário

Compartilhar em outros sites

RUSHyoutuber

Link para o comentário

Compartilhar em outros sites

landermas

Link para o comentário

Compartilhar em outros sites

RUSHyoutuber

Link para o comentário

Compartilhar em outros sites

Participe da Conversa

Popular Agora

Quem está navegando 0 membros estão online

Equipe