diff --git a/src/main/java/codechicken/nei/ItemMobSpawner.java b/src/main/java/codechicken/nei/ItemMobSpawner.java index 4b5433c3..b22c6a24 100644 --- a/src/main/java/codechicken/nei/ItemMobSpawner.java +++ b/src/main/java/codechicken/nei/ItemMobSpawner.java @@ -1,8 +1,10 @@ package codechicken.nei; -import java.util.HashMap; +import java.lang.reflect.Modifier; +import java.util.Collections; import java.util.List; import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; import net.minecraft.creativetab.CreativeTabs; import net.minecraft.entity.Entity; @@ -15,6 +17,7 @@ import net.minecraft.init.Blocks; import net.minecraft.item.Item; import net.minecraft.item.ItemBlock; import net.minecraft.item.ItemStack; +import net.minecraft.tileentity.TileEntity; import net.minecraft.tileentity.TileEntityMobSpawner; import net.minecraft.util.EnumChatFormatting; import net.minecraft.util.IIcon; @@ -26,10 +29,27 @@ import cpw.mods.fml.relauncher.SideOnly; public class ItemMobSpawner extends ItemBlock { - private static final Map entityHashMap = new HashMap<>(); - private static final Map IDtoNameMap = new HashMap<>(); - public static int idPig; - private static boolean loaded; + private static final Map entityHashMap = new ConcurrentHashMap<>(); + private static final Map IDtoNameMap = new ConcurrentHashMap<>(); + private static final Map, String> ENTITY_CLASS_TO_NAME_CACHE = new ConcurrentHashMap<>(); + + public static int idPig = 90; + private static volatile boolean loaded = false; + + // For asm + public static int placedX; + public static int placedY; + public static int placedZ; + + public static void setLastPlacedPosition(int x, int y, int z) { + placedX = x; + placedY = y; + placedZ = z; + } + + public static int[] getLastPlacedPosition() { + return new int[] { placedX, placedY, placedZ }; + } public ItemMobSpawner() { super(Blocks.mob_spawner); @@ -37,99 +57,260 @@ public class ItemMobSpawner extends ItemBlock { MinecraftForgeClient.registerItemRenderer(this, new SpawnerRenderer()); } - /** - * These are ASM translated from BlockMobSpawner - */ - public static int placedX; - public static int placedY; - public static int placedZ; - @Override - public IIcon getIconFromDamage(int par1) { + public IIcon getIconFromDamage(int meta) { return Blocks.mob_spawner.getBlockTextureFromSide(0); } - public boolean onItemUse(ItemStack itemstack, EntityPlayer entityplayer, World world, int x, int y, int z, int par7, - float par8, float par9, float par10) { - if (super.onItemUse(itemstack, entityplayer, world, x, y, z, par7, par8, par9, par10) && world.isRemote) { - TileEntityMobSpawner tileentitymobspawner = (TileEntityMobSpawner) world - .getTileEntity(placedX, placedY, placedZ); - if (tileentitymobspawner != null) { - setDefaultTag(itemstack); - String mobtype = IDtoNameMap.get(itemstack.getItemDamage()); - if (mobtype != null) { - NEICPH.sendMobSpawnerID(placedX, placedY, placedZ, mobtype); - tileentitymobspawner.func_145881_a().setEntityName(mobtype); + @Override + public boolean onItemUse(ItemStack itemstack, EntityPlayer entityplayer, World world, int x, int y, int z, int side, + float hitX, float hitY, float hitZ) { + + placedX = x; + placedY = y; + placedZ = z; + + boolean placed = super.onItemUse(itemstack, entityplayer, world, x, y, z, side, hitX, hitY, hitZ); + + if (placed && !world.isRemote) { + TileEntity tileEntity = world.getTileEntity(x, y, z); + if (tileEntity instanceof TileEntityMobSpawner) { + TileEntityMobSpawner spawner = (TileEntityMobSpawner) tileEntity; + String mobType = getMobTypeFromItemStack(itemstack); + if (mobType != null) { + spawner.func_145881_a().setEntityName(mobType); + world.markBlockForUpdate(x, y, z); + NEICPH.sendMobSpawnerID(x, y, z, mobType); } } return true; } - return false; + return placed; + } + + private String getMobTypeFromItemStack(ItemStack stack) { + int meta = getValidMetaData(stack); + return IDtoNameMap.get(meta); + } + + private int getValidMetaData(ItemStack stack) { + int meta = stack.getItemDamage(); + if (meta == 0 || !IDtoNameMap.containsKey(meta)) { + return idPig; + } + return meta; } @SideOnly(Side.CLIENT) @Override - public void addInformation(ItemStack itemstack, EntityPlayer par2EntityPlayer, List list, boolean par4) { - setDefaultTag(itemstack); - int meta = itemstack.getItemDamage(); - if (meta == 0) { - meta = idPig; + public void addInformation(ItemStack itemstack, EntityPlayer player, List tooltip, boolean advanced) { + int meta = getValidMetaData(itemstack); + EntityLiving entity = getEntity(meta); + String mobName = IDtoNameMap.get(meta); + + if (entity != null && mobName != null) { + EnumChatFormatting color = (entity instanceof IMob) ? EnumChatFormatting.DARK_RED + : EnumChatFormatting.DARK_AQUA; + tooltip.add(color + mobName); } - Entity e = getEntity(meta); - list.add( - (e instanceof IMob ? EnumChatFormatting.DARK_RED : EnumChatFormatting.DARK_AQUA) - + IDtoNameMap.get(meta)); } - public static EntityLiving getEntity(int ID) { - EntityLiving e = entityHashMap.get(ID); - if (e == null) { - loadSpawners(); - Class clazz = EntityList.IDtoClassMapping.get(ID); - World world = NEIClientUtils.mc().theWorld; - try { - e = (EntityLiving) clazz.getConstructor(new Class[] { World.class }).newInstance(world); - } catch (Throwable t) { - if (clazz == null) - NEIClientConfig.logger.error("Null class for entity (" + ID + ", " + IDtoNameMap.get(ID)); - else NEIClientConfig.logger.error("Error creating instance of entity: " + clazz.getName(), t); - e = getEntity(idPig); - } - entityHashMap.put(ID, e); + public static EntityLiving getEntity(int id) { + EntityLiving cached = entityHashMap.get(id); + if (cached != null) { + return cached; } - return e; + + loadSpawners(); + + Class entityClass = EntityList.IDtoClassMapping.get(id); + World world = NEIClientUtils.mc() != null ? NEIClientUtils.mc().theWorld : null; + + if (isInvalidEntityClass(entityClass)) { + return cacheFallback(id); + } + + EntityLiving entity = createEntityInstance(entityClass, world, id); + if (entity != null) { + entityHashMap.put(id, entity); + } + + return entity; + } + + private static boolean isInvalidEntityClass(Class entityClass) { + if (entityClass == null) { + return true; + } + + int modifiers = entityClass.getModifiers(); + if (Modifier.isAbstract(modifiers) || Modifier.isInterface(modifiers)) { + NEIClientConfig.logger.warn("Skipping abstract/interface entity class: {}", entityClass.getName()); + return true; + } + + if (!EntityLiving.class.isAssignableFrom(entityClass)) { + NEIClientConfig.logger.warn("Skipping non-EntityLiving class: {}", entityClass.getName()); + return true; + } + + return false; + } + + @SuppressWarnings("unchecked") + private static EntityLiving createEntityInstance(Class entityClass, World world, int id) { + if (entityClass == null || world == null) { + NEIClientConfig.logger.debug("World or entity class is null, using fallback for ID: {}", id); + return getFallbackEntity(id); + } + + try { + Class livingClass = (Class) entityClass; + return livingClass.getConstructor(World.class).newInstance(world); + } catch (Throwable t) { + logEntityCreationError(entityClass, id, t); + return getFallbackEntity(id); + } + } + + private static void logEntityCreationError(Class entityClass, int id, Throwable t) { + String entityName = IDtoNameMap.getOrDefault(id, "unknown"); + if (entityClass == null) { + NEIClientConfig.logger + .error("Failed to create entity instance: Class is null for ID {}, Name {}", id, entityName, t); + } else { + NEIClientConfig.logger.error( + "Failed to create instance of entity: Class {}, ID {}, Name {}", + entityClass.getName(), + id, + entityName, + t); + } + } + + private static EntityLiving cacheFallback(int id) { + EntityLiving fallback = getFallbackEntity(id); + if (fallback != null) { + entityHashMap.put(id, fallback); + } + return fallback; + } + + private static EntityLiving getFallbackEntity(int originalId) { + EntityLiving pig = entityHashMap.get(idPig); + if (pig == null) { + World world = NEIClientUtils.mc() != null ? NEIClientUtils.mc().theWorld : null; + + if (world != null) { + try { + pig = new EntityPig(world); + entityHashMap.put(idPig, pig); + NEIClientConfig.logger.debug("Created fallback pig entity for ID: {}", originalId); + } catch (Exception e) { + NEIClientConfig.logger + .error("Failed to create fallback pig entity for original ID: {}", originalId, e); + } + } else { + NEIClientConfig.logger.warn("World is null, cannot create fallback entity for ID: {}", originalId); + } + } + + return pig; } public static void clearEntityReferences() { entityHashMap.clear(); + NEIClientConfig.logger.debug("Cleared all entity references from cache"); } - private void setDefaultTag(ItemStack itemstack) { - if (!IDtoNameMap.containsKey(itemstack.getItemDamage())) itemstack.setItemDamage(idPig); - } - + @SuppressWarnings("unchecked") public static void loadSpawners() { - if (loaded) return; - loaded = true; - for (Map.Entry, String> entry : EntityList.classToStringMapping.entrySet()) { - final Class clazz = entry.getKey(); - if (EntityLiving.class.isAssignableFrom(clazz)) { - Integer id = (Integer) EntityList.classToIDMapping.get(clazz); - if (id == null) continue; - String name = entry.getValue(); - if (name == null) continue; - if (name.equals("EnderDragon")) continue; - if (name.equals("Pig")) idPig = id; - if (clazz != EntityPig.class || name.equals("Pig")) { - IDtoNameMap.put(id, name); + if (loaded) { + return; + } + + synchronized (ItemMobSpawner.class) { + try { + for (Map.Entry, String> entry : ((Map, String>) EntityList.classToStringMapping) + .entrySet()) { + + Class clazz = entry.getKey(); + String name = entry.getValue(); + + if (shouldRegisterEntity(clazz, name)) { + Integer id = (Integer) EntityList.classToIDMapping.get(clazz); + if (id != null) { + IDtoNameMap.put(id, name); + ENTITY_CLASS_TO_NAME_CACHE.put(clazz, name); + + if ("Pig".equals(name)) { + idPig = id; + NEIClientConfig.logger.debug("Set pig entity ID to: {}", id); + } + } + } } + loaded = true; + NEIClientConfig.logger.info("Loaded {} spawner entity mappings", IDtoNameMap.size()); + + } catch (Exception e) { + NEIClientConfig.logger.error("Error loading spawners from entity list", e); } } } + private static boolean shouldRegisterEntity(Class clazz, String name) { + if (clazz == null || name == null || name.trim().isEmpty()) { + return false; + } + + if (!EntityLiving.class.isAssignableFrom(clazz)) { + return false; + } + + if ("EnderDragon".equals(name) || "Giant".equals(name)) { + return false; + } + + return true; + } + @Override public void getSubItems(Item item, CreativeTabs tab, List list) { - if (!NEIClientConfig.hasSMPCounterPart()) list.add(new ItemStack(item)); - else for (int i : IDtoNameMap.keySet()) list.add(new ItemStack(item, 1, i)); + if (!NEIClientConfig.hasSMPCounterPart()) { + list.add(new ItemStack(item)); + } else { + loadSpawners(); + for (int id : IDtoNameMap.keySet()) { + ItemStack stack = new ItemStack(item, 1, id); + list.add(stack); + } + } + } + + public static String getEntityNameForMeta(int meta) { + loadSpawners(); + return IDtoNameMap.getOrDefault(meta, IDtoNameMap.getOrDefault(idPig, "Pig")); + } + + public static boolean isValidEntityMeta(int meta) { + loadSpawners(); + return IDtoNameMap.containsKey(meta) || meta == 0; + } + + public static Map getRegisteredSpawnerEntities() { + loadSpawners(); + return Collections.unmodifiableMap(IDtoNameMap); + } + + public static boolean isEntityValidForSpawner(Class entityClass) { + if (entityClass == null) return false; + + String name = ENTITY_CLASS_TO_NAME_CACHE.get(entityClass); + if (name == null) { + name = (String) EntityList.classToStringMapping.get(entityClass); + } + + return name != null && shouldRegisterEntity(entityClass, name); } }