You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
296 lines
11 KiB
Java
296 lines
11 KiB
Java
package com.zivilon.cinder_loe.util;
|
|
|
|
import com.zivilon.cinder_loe.CinderLoE;
|
|
import com.zivilon.cinder_loe.client.render.item.RenderHelper;
|
|
import com.zivilon.cinder_loe.mixins.MixinEntity;
|
|
|
|
import java.io.BufferedWriter;
|
|
import java.io.FileOutputStream;
|
|
import java.io.FileWriter;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.io.OutputStream;
|
|
import java.lang.reflect.Field;
|
|
import java.time.LocalDateTime;
|
|
import java.time.format.DateTimeFormatter;
|
|
import java.util.UUID;
|
|
import java.util.Vector;
|
|
|
|
import lotr.common.LOTRCreativeTabs;
|
|
import lotr.common.world.biome.LOTRBiome;
|
|
import lotr.common.item.LOTRItemArmor;
|
|
import lotr.common.item.LOTRMaterial;
|
|
import lotr.common.enchant.LOTREnchantment;
|
|
import lotr.common.enchant.LOTREnchantmentHelper;
|
|
|
|
import net.minecraft.client.renderer.Tessellator;
|
|
import net.minecraft.enchantment.EnchantmentHelper;
|
|
import net.minecraft.entity.Entity;
|
|
import net.minecraft.entity.EntityLiving;
|
|
import net.minecraft.entity.EntityLivingBase;
|
|
import net.minecraft.entity.SharedMonsterAttributes;
|
|
import net.minecraft.entity.player.EntityPlayer;
|
|
import net.minecraft.entity.player.EntityPlayerMP;
|
|
import net.minecraft.item.ItemStack;
|
|
import net.minecraft.item.ItemSword;
|
|
import net.minecraft.nbt.NBTBase;
|
|
import net.minecraft.nbt.NBTTagCompound;
|
|
import net.minecraft.nbt.NBTTagList;
|
|
import net.minecraft.nbt.NBTTagString;
|
|
import net.minecraft.potion.Potion;
|
|
import net.minecraft.potion.PotionEffect;
|
|
import net.minecraft.server.MinecraftServer;
|
|
|
|
|
|
public class Utilities {
|
|
|
|
public static int[] LOTRIntCache = null;
|
|
public static LOTRBiome reflected_river;
|
|
public static LOTRCreativeTabs reflected_tab_block;
|
|
|
|
public static void initialize_reflects() {
|
|
try {
|
|
Field riverField = LOTRBiome.class.getField("river");
|
|
reflected_river = (LOTRBiome)riverField.get(null);
|
|
|
|
} catch (NoSuchFieldException | IllegalAccessException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
public static void pre_init_reflects() {
|
|
try {
|
|
Field tabBlockField = LOTRCreativeTabs.class.getField("tabBlock");
|
|
reflected_tab_block = (LOTRCreativeTabs)tabBlockField.get(null);
|
|
} catch (NoSuchFieldException | IllegalAccessException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
public static EntityPlayerMP getPlayerByUUID(UUID playerUUID) {
|
|
MinecraftServer server = MinecraftServer.getServer(); // Get the server instance
|
|
if (server == null) {
|
|
return null; // Server instance is not available
|
|
}
|
|
|
|
// Iterate through the list of online players and match UUID
|
|
for (Object obj : server.getConfigurationManager().playerEntityList) {
|
|
if (obj instanceof EntityPlayerMP) {
|
|
EntityPlayerMP player = (EntityPlayerMP) obj;
|
|
if (player.getUniqueID().equals(playerUUID)) {
|
|
return player;
|
|
}
|
|
} else {
|
|
System.err.println("[CinderCore] Player list having non-players, WHAT?!?!?!");
|
|
}
|
|
}
|
|
return null; // Player not found or not online
|
|
}
|
|
|
|
public static String toSnakeCase(String input) {
|
|
if (input == null || input.isEmpty()) {
|
|
return input;
|
|
}
|
|
|
|
StringBuilder builder = new StringBuilder();
|
|
char[] chars = input.toCharArray();
|
|
|
|
builder.append(Character.toLowerCase(chars[0]));
|
|
for (int i = 1; i < chars.length; i++) {
|
|
char c = chars[i];
|
|
if (Character.isUpperCase(c)) {
|
|
builder.append('_').append(Character.toLowerCase(c));
|
|
} else {
|
|
builder.append(c);
|
|
}
|
|
}
|
|
|
|
return builder.toString();
|
|
}
|
|
|
|
public static void dumpClass(String className, String outputFilePath, Class<?> contextClass) {
|
|
// Convert class name to a resource path
|
|
String resourcePath = className.replace('.', '/') + ".class";
|
|
// Use the class loader of the context class to find the resource
|
|
try (InputStream classStream = contextClass.getClassLoader().getResourceAsStream(resourcePath)) {
|
|
if (classStream == null) {
|
|
System.err.println("Class " + className + " could not be found.");
|
|
return;
|
|
}
|
|
try (OutputStream outputStream = new FileOutputStream(outputFilePath)) {
|
|
// Copy the class stream to the output file
|
|
byte[] buffer = new byte[4096];
|
|
int bytesRead;
|
|
while ((bytesRead = classStream.read(buffer)) != -1) {
|
|
outputStream.write(buffer, 0, bytesRead);
|
|
}
|
|
System.out.println("Dumped " + className + " to " + outputFilePath);
|
|
} catch (IOException e) {
|
|
System.err.println("Failed to write class file: " + e.getMessage());
|
|
}
|
|
} catch (IOException e) {
|
|
System.err.println("Failed to read class file: " + e.getMessage());
|
|
}
|
|
}
|
|
|
|
public static void writeLog(String message) {
|
|
try (BufferedWriter writer = new BufferedWriter(new FileWriter("custom_log.txt", true))) {
|
|
LocalDateTime now = LocalDateTime.now();
|
|
String timestamp = now.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
|
|
writer.write(timestamp + " - " + message + "\n");
|
|
} catch (IOException e) {
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
|
|
public static EntityPlayer getPlayerByName(String player_name) {
|
|
MinecraftServer server = MinecraftServer.getServer();
|
|
if (server == null) {
|
|
return null;
|
|
}
|
|
|
|
for (Object obj : server.getConfigurationManager().playerEntityList) {
|
|
if (obj instanceof EntityPlayerMP) {
|
|
EntityPlayer player = (EntityPlayer)obj;
|
|
String found_name = player.getCommandSenderName();
|
|
if (found_name.equals(player_name)) {
|
|
return player;
|
|
}
|
|
}
|
|
}
|
|
return null; // Player not found or not online
|
|
}
|
|
|
|
public static boolean hasFireWeapon(String player_name) {
|
|
EntityPlayer player = getPlayerByName(player_name);
|
|
|
|
if (player == null) {
|
|
System.out.println("[CinderLoE] Warning! Player not found: " + player_name);
|
|
return false;
|
|
}
|
|
|
|
ItemStack held_item = player.getHeldItem();
|
|
boolean has_fire = LOTREnchantmentHelper.hasEnchant(held_item, LOTREnchantment.fire);
|
|
return has_fire;
|
|
}
|
|
|
|
public static boolean has_fire_weapon(Entity entity) {
|
|
if (!(entity instanceof EntityLivingBase)) return false;
|
|
ItemStack held_item = ((EntityLivingBase)entity).getHeldItem();
|
|
return LOTREnchantmentHelper.hasEnchant(held_item, LOTREnchantment.fire);
|
|
}
|
|
|
|
public static int[] countNexArmour(String player_name) {
|
|
EntityPlayer player = getPlayerByName(player_name);
|
|
int[] nexPieces = new int[4];
|
|
|
|
if (player == null) {
|
|
System.out.println("[CinderLoE] Warning! Player not found: " + player_name);
|
|
return nexPieces;
|
|
}
|
|
|
|
for (ItemStack armor : player.inventory.armorInventory) {
|
|
if (armor != null && armor.getItem() instanceof LOTRItemArmor) {
|
|
LOTRItemArmor itemArmor = (LOTRItemArmor) armor.getItem();
|
|
if (itemArmor.getLOTRArmorMaterial() == CinderLoE.MATERIAL_NEX_ICE) {
|
|
nexPieces[0]++;
|
|
} else if (itemArmor.getLOTRArmorMaterial() == CinderLoE.MATERIAL_NEX_FIRE) {
|
|
nexPieces[1]++;
|
|
} else if (itemArmor.getLOTRArmorMaterial() == CinderLoE.MATERIAL_NEX_SHADOW) {
|
|
nexPieces[2]++;
|
|
} else if (itemArmor.getLOTRArmorMaterial() == CinderLoE.MATERIAL_NEX_TOXIN) {
|
|
nexPieces[3]++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (nexPieces[0] == 4) nexPieces[0] = 5;
|
|
if (nexPieces[1] == 4) nexPieces[1] = 5;
|
|
if (nexPieces[2] == 4) nexPieces[2] = 5;
|
|
if (nexPieces[3] == 4) nexPieces[3] = 5;
|
|
|
|
return nexPieces;
|
|
}
|
|
|
|
public static double calculate_melee_damage_on_entity(EntityLivingBase target, EntityLivingBase attacker) {
|
|
if (attacker == null) return 0.0D;
|
|
if (attacker.getEntityAttribute(SharedMonsterAttributes.attackDamage) == null) return 0.0D;
|
|
|
|
double attribute = attacker.getEntityAttribute(SharedMonsterAttributes.attackDamage).getAttributeValue();
|
|
double enchantments = EnchantmentHelper.getEnchantmentModifierLiving(attacker, target);
|
|
boolean is_critical = !attacker.onGround && attacker.motionY < 0.0D && !attacker.isInWater() && !attacker.isRiding();
|
|
double critical = 0.0D;
|
|
if (is_critical) {
|
|
PotionEffect strength_effect = attacker.getActivePotionEffect(Potion.damageBoost);
|
|
if (strength_effect == null) {
|
|
critical = Math.min((attribute + enchantments) * 1.5D, 7.0D);
|
|
} else {
|
|
int level = strength_effect.getAmplifier() + 1;
|
|
critical = Math.min((attribute + enchantments) * 1.5D, 7.0D * (1.0D + 0.5D * level));
|
|
}
|
|
}
|
|
return attribute + enchantments + critical;
|
|
}
|
|
|
|
public static boolean isArrayEmpty(int[] array) {
|
|
for (int value : array) {
|
|
if (value != 0) return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public static void setInvulnerable(Entity entity, boolean invulnerable) {
|
|
((MixinEntity)entity).setInvulnerable(invulnerable);
|
|
}
|
|
|
|
public static void setLOTREnchant(ItemStack itemstack, LOTREnchantment ench) {
|
|
NBTTagList tags = getItemEnchantTags(itemstack, true);
|
|
if (tags != null) {
|
|
String enchName = ench.enchantName;
|
|
tags.appendTag((NBTBase)new NBTTagString(enchName));
|
|
}
|
|
}
|
|
|
|
public static NBTTagList getItemEnchantTags(ItemStack itemstack, boolean create) {
|
|
NBTTagCompound itemData = itemstack.getTagCompound();
|
|
NBTTagList tags = null;
|
|
if (itemData != null && itemData.hasKey("LOTREnch")) {
|
|
tags = itemData.getTagList("LOTREnch", 8);
|
|
} else if (create) {
|
|
if (itemData == null) {
|
|
itemData = new NBTTagCompound();
|
|
itemstack.setTagCompound(itemData);
|
|
}
|
|
tags = new NBTTagList();
|
|
itemData.setTag("LOTREnch", (NBTBase)tags);
|
|
}
|
|
return tags;
|
|
}
|
|
|
|
public static void setAppliedRandomEnchants(ItemStack itemstack) {
|
|
if (!itemstack.hasTagCompound())
|
|
itemstack.setTagCompound(new NBTTagCompound());
|
|
itemstack.getTagCompound().setBoolean("LOTRRandomEnch", true);
|
|
}
|
|
|
|
public static void knockback(EntityLivingBase target, EntityLivingBase attacker, double knockback_strength) {
|
|
// Calculate direction of knockback
|
|
double dx = attacker.posX - target.posX;
|
|
double dz = attacker.posZ - target.posZ;
|
|
|
|
// Normalize the direction vector
|
|
double distance = Math.sqrt(dx * dx + dz * dz);
|
|
if (distance != 0) {
|
|
dx /= distance;
|
|
dz /= distance;
|
|
}
|
|
|
|
// Apply knockback manually
|
|
target.motionX -= dx * knockback_strength;
|
|
target.motionZ -= dz * knockback_strength;
|
|
|
|
// Ensure the motion is applied
|
|
target.velocityChanged = true;
|
|
}
|
|
}
|