[UTIL] HorseModifier - Spawn and modify horses!

HorseModifier v1.1:

Hey there guys, it's me again, in a thread was asked how to change the type of a horse, so I decided to make a class which makes this possible. Besides that, there are also methods for the other specific values of a horse!

Important: I haven't tested this class, because it's not possible atm to cast entities to horses...(EntityType of a horse entity is handled as "Unknown") Just tested all functions with the new spawn method and it works great

Usage:

Code:java

HorseModifier hm = new HorseModifier(HORSE);
hm.setType(HorseType.NAME);
hm.setVariant(HorseVariant.NAME);
hm.setTamed(true/false);
.....

or

Code:java

HorseModifier hm = HorseModifier.spawn(LOCATION);
hm.setType(HorseType.NAME);
hm.setVariant(HorseVariant.NAME);
hm.setTamed(true/false);
.....

HorseModifier class:

Code:java

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import java.util.Map.Entry;
 
import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.inventory.ItemStack;
 
/**
* HorseModifier v1.1
*
* You are free to use it, modify it and redistribute it under the condition to give credit to me
*
* @author DarkBlade12
*/
public class HorseModifier {
    private Object entityHorse;
    private Object nbtTagCompound;
 
    /**
    * Creates a new instance of the HorseModifier, which allows you to change/get values of horses which aren't accessible with the bukkit api atm
    */
    public HorseModifier(LivingEntity horse) {
        if (!HorseModifier.isHorse(horse)) {
            throw new IllegalArgumentException("Entity has to be a horse!");
        }
        try {
            this.entityHorse = ReflectionUtil.getMethod("getHandle", horse.getClass(), 0).invoke(horse);
            this.nbtTagCompound = NBTUtil.getNBTTagCompound(entityHorse);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    /**
    * Creates a new instance of the HorseModifier; This constructor is only used for the static spawn method
    */
    private HorseModifier(Object entityHorse) {
        this.entityHorse = entityHorse;
        try {
            this.nbtTagCompound = NBTUtil.getNBTTagCompound(entityHorse);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    /**
    * Spawns a horse at a given location
    */
    public static HorseModifier spawn(Location loc) {
        World w = loc.getWorld();
        try {
            Object worldServer = ReflectionUtil.getMethod("getHandle", w.getClass(), 0).invoke(w);
            Object entityHorse = ReflectionUtil.getClass("EntityHorse", worldServer);
            ReflectionUtil.getMethod("setPosition", entityHorse.getClass(), 3).invoke(entityHorse, loc.getX(), loc.getY(), loc.getZ());
            ReflectionUtil.getMethod("addEntity", worldServer.getClass(), 1).invoke(worldServer, entityHorse);
            return new HorseModifier(entityHorse);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
 
    /**
    * Checks if an entity is a horse
    */
    public static boolean isHorse(LivingEntity le) {
        try {
            Object entityLiving = ReflectionUtil.getMethod("getHandle", le.getClass(), 0).invoke(le);
            Object nbtTagCompound = NBTUtil.getNBTTagCompound(entityLiving);
            return NBTUtil.hasKeys(nbtTagCompound, new String[] { "EatingHaystack", "ChestedHorse", "HasReproduced", "Bred", "Type", "Variant", "Temper", "Tame" });
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
 
    /**
    * Changes the type of the horse
    */
    public void setType(HorseType type) {
        setHorseValue("Type", type.getId());
    }
 
    /**
    * Changes whether the horse is chested or not (only for donkeys and mules)
    */
    public void setChested(boolean chested) {
        setHorseValue("ChestedHorse", chested);
    }
 
    /**
    * Changes whether the horse is eating or not
    */
    public void setEating(boolean eating) {
        setHorseValue("EatingHaystack", eating);
    }
 
    /**
    * Changes whether the horse was bred or not
    */
    public void setBred(boolean bred) {
        setHorseValue("Bred", bred);
    }
 
    /**
    * Changes the color variant of the horse (only for normal horses)
    */
    public void setVariant(HorseVariant variant) {
        setHorseValue("Variant", variant.getId());
    }
 
    /**
    * Changes the temper of the horse
    */
    public void setTemper(int temper) {
        setHorseValue("Temper", temper);
    }
 
    /**
    * Changes whether the horse is tamed or not
    */
    public void setTamed(boolean tamed) {
        setHorseValue("Tame", tamed);
    }
 
    /**
    * Changes whether the horse is saddled or not
    */
    public void setSaddled(boolean saddled) {
        setHorseValue("Saddle", saddled);
    }
 
    /**
    * Sets the armor item of the horse (only for normal horses)
    */
    public void setArmorItem(ItemStack i) {
        if (i != null) {
            try {
                Object itemTag = ReflectionUtil.getClass("NBTTagCompound", "ArmorItem");
                Object itemStack = ReflectionUtil.getMethod("asNMSCopy", Class.forName(Bukkit.getServer().getClass().getPackage().getName() + ".inventory.CraftItemStack"), 1).invoke(this, i);
                ReflectionUtil.getMethod("save", itemStack.getClass(), 1).invoke(itemStack, itemTag);
                setHorseValue("ArmorItem", itemTag);
            } catch (Exception e) {
                e.printStackTrace();
            }
        } else {
            setHorseValue("ArmorItem", null);
        }
    }
 
    /**
    * Returns the type of the horse
    */
    public HorseType getType() {
        return HorseType.fromId((int) NBTUtil.getValue(nbtTagCompound, Integer.class, "Type"));
    }
 
    /**
    * Returns whether the horse is chested or not
    */
    public boolean isChested() {
        return (boolean) NBTUtil.getValue(nbtTagCompound, Boolean.class, "ChestedHorse");
    }
 
    /**
    * Returns whether the horse is eating or not
    */
    public boolean isEating() {
        return (boolean) NBTUtil.getValue(nbtTagCompound, Boolean.class, "EatingHaystack");
    }
 
    /**
    * Returns whether the horse was bred or not
    */
    public boolean isBred() {
        return (boolean) NBTUtil.getValue(nbtTagCompound, Boolean.class, "Bred");
    }
 
    /**
    * Returns the variant of the horse
    */
    public HorseVariant getVariant() {
        return HorseVariant.fromId((int) NBTUtil.getValue(nbtTagCompound, Integer.class, "Variant"));
    }
 
    /**
    * Returns the temper of the horse
    */
    public int getTemper() {
        return (int) NBTUtil.getValue(nbtTagCompound, Integer.class, "Temper");
    }
 
    /**
    * Returns whether the horse is tamed or not
    */
    public boolean isTamed() {
        return (boolean) NBTUtil.getValue(nbtTagCompound, Boolean.class, "Tame");
    }
 
    /**
    * Returns whether the horse is saddled or not
    */
    public boolean isSaddled() {
        return (boolean) NBTUtil.getValue(nbtTagCompound, Boolean.class, "Saddle");
    }
 
    /**
    * Returns the armor item of the horse
    */
    public ItemStack getArmorItem() {
        try {
            Object itemTag = NBTUtil.getValue(nbtTagCompound, nbtTagCompound.getClass(), "ArmorItem");
            Object itemStack = ReflectionUtil.getMethod("createStack", Class.forName(ReflectionUtil.getPackageName() + ".ItemStack"), 1).invoke(this, itemTag);
            return (ItemStack) ReflectionUtil.getMethod("asCraftMirror", Class.forName(Bukkit.getServer().getClass().getPackage().getName() + ".inventory.CraftItemStack"), 1).invoke(this, itemStack);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
 
    /**
    * Opens the inventory of the horse for a player (only for tamed horses)
    */
    public void openInventory(Player p) {
        try {
            Object entityPlayer = ReflectionUtil.getMethod("getHandle", p.getClass(), 0).invoke(p);
            ReflectionUtil.getMethod("f", entityHorse.getClass(), 1).invoke(entityHorse, entityPlayer);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
 
    /**
    * Returns the horse entity
    */
    public LivingEntity getHorse() {
        try {
            return (LivingEntity) ReflectionUtil.getMethod("getBukkitEntity", entityHorse.getClass(), 0).invoke(entityHorse);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }
 
    /**
    * Changes a value in the NBTTagCompound and updates it to the horse
    */
    private void setHorseValue(String key, Object value) {
        NBTUtil.setValue(nbtTagCompound, key, value);
        NBTUtil.updateNBTTagCompound(entityHorse, nbtTagCompound);
    }
 
    public enum HorseType {
 
        NORMAL("normal", 0), DONKEY("donkey", 1), MULE("mule", 2), UNDEAD("undead", 3), SKELETAL("skeletal", 4);
 
        private String name;
        private int id;
 
        HorseType(String name, int id) {
            this.name = name;
            this.id = id;
        }
 
        public String getName() {
            return name;
        }
 
        public int getId() {
            return id;
        }
 
        private static final Map<String, HorseType> NAME_MAP = new HashMap<String, HorseType>();
        private static final Map<Integer, HorseType> ID_MAP = new HashMap<Integer, HorseType>();
        static {
            for (HorseType effect : values()) {
                NAME_MAP.put(effect.name, effect);
                ID_MAP.put(effect.id, effect);
            }
        }
 
        public static HorseType fromName(String name) {
            if (name == null) {
                return null;
            }
            for (Entry<String, HorseType> e : NAME_MAP.entrySet()) {
                if (e.getKey().equalsIgnoreCase(name)) {
                    return e.getValue();
                }
            }
            return null;
        }
 
        public static HorseType fromId(int id) {
            return ID_MAP.get(id);
        }
    }
 
    public enum HorseVariant {
        WHITE("white", 0), CREAMY("creamy", 1), CHESTNUT("chestnut", 2), BROWN("brown", 3), BLACK("black", 4), GRAY("gray", 5), DARK_BROWN("dark brown", 6), INVISIBLE("invisible", 7), WHITE_WHITE(
                "white-white", 256), CREAMY_WHITE("creamy-white", 257), CHESTNUT_WHITE("chestnut-white", 258), BROWN_WHITE("brown-white", 259), BLACK_WHITE("black-white", 260), GRAY_WHITE("gray-white", 261), DARK_BROWN_WHITE(
                "dark brown-white", 262), WHITE_WHITE_FIELD("white-white field", 512), CREAMY_WHITE_FIELD("creamy-white field", 513), CHESTNUT_WHITE_FIELD("chestnut-white field", 514), BROWN_WHITE_FIELD(
                "brown-white field", 515), BLACK_WHITE_FIELD("black-white field", 516), GRAY_WHITE_FIELD("gray-white field", 517), DARK_BROWN_WHITE_FIELD("dark brown-white field", 518), WHITE_WHITE_DOTS(
                "white-white dots", 768), CREAMY_WHITE_DOTS("creamy-white dots", 769), CHESTNUT_WHITE_DOTS("chestnut-white dots", 770), BROWN_WHITE_DOTS("brown-white dots", 771), BLACK_WHITE_DOTS(
                "black-white dots", 772), GRAY_WHITE_DOTS("gray-white dots", 773), DARK_BROWN_WHITE_DOTS("dark brown-white dots", 774), WHITE_BLACK_DOTS("white-black dots", 1024), CREAMY_BLACK_DOTS(
                "creamy-black dots", 1025), CHESTNUT_BLACK_DOTS("chestnut-black dots", 1026), BROWN_BLACK_DOTS("brown-black dots", 1027), BLACK_BLACK_DOTS("black-black dots", 1028), GRAY_BLACK_DOTS(
                "gray-black dots", 1029), DARK_BROWN_BLACK_DOTS("dark brown-black dots", 1030);
 
        private String name;
        private int id;
 
        HorseVariant(String name, int id) {
            this.name = name;
            this.id = id;
        }
 
        public String getName() {
            return name;
        }
 
        public int getId() {
            return id;
        }
 
        private static final Map<String, HorseVariant> NAME_MAP = new HashMap<String, HorseVariant>();
        private static final Map<Integer, HorseVariant> ID_MAP = new HashMap<Integer, HorseVariant>();
        static {
            for (HorseVariant effect : values()) {
                NAME_MAP.put(effect.name, effect);
                ID_MAP.put(effect.id, effect);
            }
        }
 
        public static HorseVariant fromName(String name) {
            if (name == null) {
                return null;
            }
            for (Entry<String, HorseVariant> e : NAME_MAP.entrySet()) {
                if (e.getKey().equalsIgnoreCase(name)) {
                    return e.getValue();
                }
            }
            return null;
        }
 
        public static HorseVariant fromId(int id) {
            return ID_MAP.get(id);
        }
    }
 
    private static class NBTUtil {
        public static Object getNBTTagCompound(Object entity) {
            try {
                Object nbtTagCompound = ReflectionUtil.getClass("NBTTagCompound");
                for (Method m : entity.getClass().getMethods()) {
                    Class<?>[] pt = m.getParameterTypes();
                    if (m.getName().equals("b") && pt.length == 1 && pt[0].getName().contains("NBTTagCompound")) {
                        m.invoke(entity, nbtTagCompound);
                    }
                }
                return nbtTagCompound;
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
 
        public static void updateNBTTagCompound(Object entity, Object nbtTagCompound) {
            try {
                for (Method m : entity.getClass().getMethods()) {
                    Class<?>[] pt = m.getParameterTypes();
                    if (m.getName().equals("a") && pt.length == 1 && pt[0].getName().contains("NBTTagCompound")) {
                        m.invoke(entity, nbtTagCompound);
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
 
        public static void setValue(Object nbtTagCompound, String key, Object value) {
            try {
                if (value instanceof Integer) {
                    ReflectionUtil.getMethod("setInt", nbtTagCompound.getClass(), 2).invoke(nbtTagCompound, key, (Integer) value);
                    return;
                } else if (value instanceof Boolean) {
                    ReflectionUtil.getMethod("setBoolean", nbtTagCompound.getClass(), 2).invoke(nbtTagCompound, key, (Boolean) value);
                    return;
                } else {
                    ReflectionUtil.getMethod("set", nbtTagCompound.getClass(), 2).invoke(nbtTagCompound, key, value);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
 
        public static Object getValue(Object nbtTagCompound, Class<?> c, String key) {
            try {
                if (c == Integer.class) {
                    return ReflectionUtil.getMethod("getInt", nbtTagCompound.getClass(), 1).invoke(nbtTagCompound, key);
                } else if (c == Boolean.class) {
                    return ReflectionUtil.getMethod("getBoolean", nbtTagCompound.getClass(), 1).invoke(nbtTagCompound, key);
                } else {
                    return ReflectionUtil.getMethod("getCompound", nbtTagCompound.getClass(), 1).invoke(nbtTagCompound, key);
                }
            } catch (Exception e) {
                e.printStackTrace();
                return null;
            }
        }
 
        public static boolean hasKey(Object nbtTagCompound, String key) {
            try {
                return (boolean) ReflectionUtil.getMethod("hasKey", nbtTagCompound.getClass(), 1).invoke(nbtTagCompound, key);
            } catch (Exception e) {
                e.printStackTrace();
                return false;
            }
        }
 
        public static boolean hasKeys(Object nbtTagCompound, String[] keys) {
            for (String key : keys) {
                if (!hasKey(nbtTagCompound, key)) {
                    return false;
                }
            }
            return true;
        }
    }
 
    private static class ReflectionUtil {
        public static Object getClass(String name, Object... args) throws Exception {
            Class<?> c = Class.forName(ReflectionUtil.getPackageName() + "." + name);
            int params = 0;
            if (args != null) {
                params = args.length;
            }
            for (Constructor<?> co : c.getConstructors()) {
                if (co.getParameterTypes().length == params) {
                    return co.newInstance(args);
                }
            }
            return null;
        }
 
        public static Method getMethod(String name, Class<?> c, int params) {
            for (Method m : c.getMethods()) {
                if (m.getName().equals(name) && m.getParameterTypes().length == params) {
                    return m;
                }
            }
            return null;
        }
 
        public static String getPackageName() {
            return "net.minecraft.server." + Bukkit.getServer().getClass().getPackage().getName().replace(".", ",").split(",")[3];
        }
    }
}

 

Thanks for this!
I wonder why they don't have a native API for the Horses... hmm.

 

This is pretty cool, it should help us until the api gets implemented! Thanks!
Edit:
How can I use this to spawn a zombie horse?

 

They released the dev build like the day after 1.6 came out, they need time for an API.

 

True, true. I'm in no rush, I appreciate all the work they do already

 

AstramG That's how you do it:

Code:java

HorseModifier.spawn(LOCATION).setType(HorseType.UNDEAD);

 

Thank you very much. You're blessed

 

How do I use the Horse h = ....; part? Confused.

 

Prang123 Well there should be the part how you get it, either spawn it or cast from an entity. But there's a bug which prevents you from spawning/casting horses, maybe I'll add a method which allows you to spawn a horse via NMS through reflection

 

Hey DarkBladee12 , there's a way to get the horse's inventory?

 

Omerrg Not yet, but thanks for the suggestion, I'm trying to add this

 

Thanks alot for this, finaly we can spawn all the horses. Do you mind if i make a simple spawn horse plugin? i'l make sure to give full credit to you

 

imjack16 Nope, it won't mind that You're welcome to use it as long as you give credit to me.

 

After completely reading it, it looks very, sexily helpful, and it might be very nice to have in a plugin. I am going to use this to stuff around with the obfuscated methods that EntityHorse holds Thanks!

 

https://github.com/Bukkit/Bukkit/pull/889
I pulled Horse.java to add the types

 

Rockon999 That's nice, I hope they'll implement your changes

 

Ok so how do I use this?

 

daylight95 Just read the first post, the usage is described there! You'll also have to make a new class named "HorseModifier" and copy the code from the first post in order to use it.

 

Anyway to set the horses health since it sets it currently at max?

 

imjack16 You could try this, but I'm not sure if it works:

Code:java

MODIFIER.getHorse().setMaxHealth(AMOUNT);

 

Yo, I was getting errors while using

Code:java

return (boolean) NBTTag.compound...

But I changed it to

Code:java

return (Boolean) NBTTag.compound...

And it worked..

Is this a Java error, or just my stupid IDE? I'm not sure, but the primitive types didn't work, so I changed them to Boolean or Integer. Hope you can fix this, or explain why.

 

kreashenz Could you tell me which method threw that error?

 

DarkBladee12 All the boolean ones, and all the int ones. I've edited them all, gimme a moment.

Images (open) Images (close)

 

kreashenz Well I think it's just your IDE, it doesn't show me that errors when I'm looking at the class in eclipse... But the way you solved it shouldn't change anything on the functionality

 

DarkBladee12 Yeah, that's what I thought. Thanks

 

I ended up making this with it.... (Fiery smoking skeleton horse of evil >)

 

VoidWhisperer Nice

 

Didn't see it, but is there any way to check who is the owner of a tamed horse?

 

MistPhizzle
No, horses don't have owners.
You need to store that data yourself.

 

What are the possible temper values?