diff --git a/client/forge_logo.png b/client/forge_logo.png new file mode 100644 index 0000000000..19a02ca4b7 Binary files /dev/null and b/client/forge_logo.png differ diff --git a/client/net/minecraftforge/client/EnumHelperClient.java b/client/net/minecraftforge/client/EnumHelperClient.java new file mode 100644 index 0000000000..dcb4719832 --- /dev/null +++ b/client/net/minecraftforge/client/EnumHelperClient.java @@ -0,0 +1,44 @@ +package net.minecraftforge.client; + +import net.minecraft.src.EnumGameType; +import net.minecraft.src.EnumOS; +import net.minecraft.src.EnumOptions; +import net.minecraft.src.EnumRarity; +import net.minecraftforge.common.EnumHelper; + +public class EnumHelperClient extends EnumHelper +{ + + private static Class[][] clentTypes = + { + {EnumGameType.class, int.class, String.class}, + {EnumOptions.class, String.class, boolean.class, boolean.class}, + {EnumOS.class}, + {EnumRarity.class, int.class, String.class} + }; + + public static EnumGameType addGameType(String name, int id, String displayName) + { + return addEnum(EnumGameType.class, name, id, displayName); + } + + public static EnumOptions addOptions(String name, String langName, boolean isSlider, boolean isToggle) + { + return addEnum(EnumOptions.class, name, langName, isSlider, isToggle); + } + + public static EnumOS addOS2(String name) + { + return addEnum(EnumOS.class, name); + } + + public static EnumRarity addRarity(String name, int color, String displayName) + { + return addEnum(EnumRarity.class, name, color, displayName); + } + + public static > T addEnum(Class enumType, String enumName, Object... paramValues) + { + return addEnum(clentTypes, enumType, enumName, paramValues); + } +} diff --git a/common/forge_at.cfg b/common/forge_at.cfg new file mode 100644 index 0000000000..07d03a580d --- /dev/null +++ b/common/forge_at.cfg @@ -0,0 +1,20 @@ +[ +{ + "modid" : "mod_MinecraftForge", + "name" : "Minecraft Forge", + "version" : "{version}", + "url" : "http://MinecraftForge.net", + "credits" : "Lots of people have contributed to MinecraftForge", + "authors": [ + "LexManos", + "Eloraam", + "Spacetoad" + ], + "description": "Minecraft Forge is a common open source API allowing a broad range of mods to work cooperatively together.\nIt allows many mods to be created without them editing the main Minecraft code.", + "logoFile" : "/forge_logo.png", + "updateUrl" : "http://minecraftforge.net/forum/index.php/topic,5.0.html", + "parent" : "", + "screenshots": [ + ] +} +] \ No newline at end of file diff --git a/common/net/minecraftforge/classloading/FMLForgePlugin.java b/common/net/minecraftforge/classloading/FMLForgePlugin.java new file mode 100644 index 0000000000..add70921ba --- /dev/null +++ b/common/net/minecraftforge/classloading/FMLForgePlugin.java @@ -0,0 +1,40 @@ +package net.minecraftforge.classloading; + +import java.util.Map; + +import cpw.mods.fml.relauncher.IFMLLoadingPlugin; + +public class FMLForgePlugin implements IFMLLoadingPlugin +{ + @Override + public String[] getLibraryRequestClass() + { + return null; + } + + @Override + public String[] getASMTransformerClass() + { + return new String[]{ + "net.minecraftforge.transformers.ForgeAccessTransformer", + "net.minecraftforge.transformers.EventTransformer" + }; + } + + @Override + public String getModContainerClass() + { + return "net.minecraftforge.common.ForgeDummyContainer"; + } + + @Override + public String getSetupClass() + { + return null; + } + + @Override + public void injectData(Map data) + { + } +} diff --git a/common/net/minecraftforge/common/EnumHelper.java b/common/net/minecraftforge/common/EnumHelper.java new file mode 100644 index 0000000000..b810c46303 --- /dev/null +++ b/common/net/minecraftforge/common/EnumHelper.java @@ -0,0 +1,239 @@ +package net.minecraftforge.common; + +import net.minecraft.src.*; +import java.lang.reflect.*; +import java.util.*; + +public class EnumHelper +{ + private static Object reflectionFactory = null; + private static Method newConstructorAccessor = null; + private static Method newInstance = null; + private static Method newFieldAccessor = null; + private static Method fieldAccessorSet = null; + private static boolean isSetup = false; + + //Some enums are decompiled with extra arguments, so lets check for that + private static Class[][] commonTypes = + { + {EnumAction.class}, + {EnumArmorMaterial.class, int.class, int[].class, int.class}, + {EnumArt.class, String.class, int.class, int.class, int.class, int.class}, + {EnumCreatureAttribute.class}, + {EnumCreatureType.class, Class.class, int.class, Material.class, boolean.class}, + {EnumDoor.class}, + {EnumEnchantmentType.class}, + {EnumEntitySize.class}, + {EnumMobType.class}, + {EnumMovingObjectType.class}, + {EnumSkyBlock.class, int.class}, + {EnumStatus.class}, + {EnumToolMaterial.class, int.class, int.class, float.class, int.class, int.class} + }; + + public static EnumAction addAction(String name) + { + return addEnum(EnumAction.class, name); + } + public static EnumArmorMaterial addArmorMaterial(String name, int durability, int[] reductionAmounts, int enchantability) + { + return addEnum(EnumArmorMaterial.class, name, durability, reductionAmounts, enchantability); + } + public static EnumArt addArt(String name, String tile, int sizeX, int sizeY, int offsetX, int offsetY) + { + return addEnum(EnumArt.class, name, tile, sizeX, sizeY, offsetX, offsetY); + } + public static EnumCreatureAttribute addCreatureAttribute(String name) + { + return addEnum(EnumCreatureAttribute.class, name); + } + public static EnumCreatureType addCreatureType(String name, Class typeClass, int maxNumber, Material material, boolean peaceful) + { + return addEnum(EnumCreatureType.class, name, typeClass, maxNumber, material, peaceful); + } + public static EnumDoor addDoor(String name) + { + return addEnum(EnumDoor.class, name); + } + public static EnumEnchantmentType addEnchantmentType(String name) + { + return addEnum(EnumEnchantmentType.class, name); + } + public static EnumEntitySize addEntitySize(String name) + { + return addEnum(EnumEntitySize.class, name); + } + public static EnumMobType addMobType(String name) + { + return addEnum(EnumMobType.class, name); + } + public static EnumMovingObjectType addMovingObjectType(String name) + { + if (!isSetup) + { + setup(); + } + + return addEnum(EnumMovingObjectType.class, name); + } + public static EnumSkyBlock addSkyBlock(String name, int lightValue) + { + return addEnum(EnumSkyBlock.class, name, lightValue); + } + public static EnumStatus addStatus(String name) + { + return addEnum(EnumStatus.class, name); + } + public static EnumToolMaterial addToolMaterial(String name, int harvestLevel, int maxUses, float efficiency, int damage, int enchantability) + { + return addEnum(EnumToolMaterial.class, name, harvestLevel, maxUses, efficiency, damage, enchantability); + } + + private static void setup() + { + if (isSetup) + { + return; + } + + try + { + Method getReflectionFactory = Class.forName("sun.reflect.ReflectionFactory").getDeclaredMethod("getReflectionFactory"); + reflectionFactory = getReflectionFactory.invoke(null); + newConstructorAccessor = Class.forName("sun.reflect.ReflectionFactory").getDeclaredMethod("newConstructorAccessor", Constructor.class); + newInstance = Class.forName("sun.reflect.ConstructorAccessor").getDeclaredMethod("newInstance", Object[].class); + newFieldAccessor = Class.forName("sun.reflect.ReflectionFactory").getDeclaredMethod("newFieldAccessor", Field.class, boolean.class); + fieldAccessorSet = Class.forName("sun.reflect.FieldAccessor").getDeclaredMethod("set", Object.class, Object.class); + } + catch (Exception e) + { + e.printStackTrace(); + } + + isSetup = true; + } + + /* + * Everything below this is found at the site below, and updated to be able to compile in Eclipse/Java 1.6+ + * Also modified for use in decompiled code. + * Found at: http://niceideas.ch/roller2/badtrash/entry/java_create_enum_instances_dynamically + */ + private static Object getConstructorAccessor(Class enumClass, Class[] additionalParameterTypes) throws Exception + { + Class[] parameterTypes = new Class[additionalParameterTypes.length + 2]; + parameterTypes[0] = String.class; + parameterTypes[1] = int.class; + System.arraycopy(additionalParameterTypes, 0, parameterTypes, 2, additionalParameterTypes.length); + return newConstructorAccessor.invoke(reflectionFactory, enumClass.getDeclaredConstructor(parameterTypes)); + } + + private static < T extends Enum> T makeEnum(Class enumClass, String value, int ordinal, Class[] additionalTypes, Object[] additionalValues) throws Exception + { + Object[] parms = new Object[additionalValues.length + 2]; + parms[0] = value; + parms[1] = Integer.valueOf(ordinal); + System.arraycopy(additionalValues, 0, parms, 2, additionalValues.length); + return enumClass.cast(newInstance.invoke(getConstructorAccessor(enumClass, additionalTypes), new Object[] {parms})); + } + + public static void setFailsafeFieldValue(Field field, Object target, Object value) throws Exception + { + field.setAccessible(true); + Field modifiersField = Field.class.getDeclaredField("modifiers"); + modifiersField.setAccessible(true); + modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL); + Object fieldAccessor = newFieldAccessor.invoke(reflectionFactory, field, false); + fieldAccessorSet.invoke(fieldAccessor, target, value); + } + + private static void blankField(Class enumClass, String fieldName) throws Exception + { + for (Field field : Class.class.getDeclaredFields()) + { + if (field.getName().contains(fieldName)) + { + field.setAccessible(true); + setFailsafeFieldValue(field, enumClass, null); + break; + } + } + } + + private static void cleanEnumCache(Class enumClass) throws Exception + { + blankField(enumClass, "enumConstantDirectory"); + blankField(enumClass, "enumConstants"); + } + + public static > T addEnum(Class enumType, String enumName, Object... paramValues) + { + return addEnum(commonTypes, enumType, enumName, paramValues); + } + + public static > T addEnum(Class[][] map, Class enumType, String enumName, Object... paramValues) + { + for (Class[] lookup : map) + { + if (lookup[0] == enumType) + { + Class[] paramTypes = new Class[lookup.length - 1]; + if (paramTypes.length > 0) + { + System.arraycopy(lookup, 1, paramTypes, 0, paramTypes.length); + } + return addEnum(enumType, enumName, paramTypes, paramValues); + } + } + return null; + } + + @SuppressWarnings("unchecked") + public static > T addEnum(Class enumType, String enumName, Class[] paramTypes, Object[] paramValues) + { + if (!isSetup) + { + setup(); + } + + Field valuesField = null; + Field[] fields = enumType.getDeclaredFields(); + int flags = Modifier.PRIVATE | Modifier.STATIC | Modifier.FINAL | 0x1000 /*SYNTHETIC*/; + String valueType = String.format("[L%s;", enumType.getName().replace('.', '/')); + + for (Field field : fields) + { + if ((field.getModifiers() & flags) == flags && + field.getType().getName().replace('.', '/').equals(valueType)) //Apparently some JVMs return .'s and some don't.. + { + valuesField = field; + break; + } + } + valuesField.setAccessible(true); + + try + { + T[] previousValues = (T[])valuesField.get(enumType); + List values = new ArrayList(Arrays.asList(previousValues)); + T newValue = (T)makeEnum(enumType, enumName, values.size(), paramTypes, paramValues); + values.add(newValue); + setFailsafeFieldValue(valuesField, null, values.toArray((T[]) Array.newInstance(enumType, 0))); + cleanEnumCache(enumType); + + return newValue; + } + catch (Exception e) + { + e.printStackTrace(); + throw new RuntimeException(e.getMessage(), e); + } + } + + static + { + if (!isSetup) + { + setup(); + } + } +} \ No newline at end of file diff --git a/common/net/minecraftforge/common/ForgeDummyContainer.java b/common/net/minecraftforge/common/ForgeDummyContainer.java new file mode 100644 index 0000000000..22be4b0d9f --- /dev/null +++ b/common/net/minecraftforge/common/ForgeDummyContainer.java @@ -0,0 +1,39 @@ +package net.minecraftforge.common; + +import java.util.Arrays; + +import com.google.common.eventbus.EventBus; + +import cpw.mods.fml.common.DummyModContainer; +import cpw.mods.fml.common.LoadController; +import cpw.mods.fml.common.Loader; +import cpw.mods.fml.common.ModMetadata; + +import static net.minecraftforge.common.ForgeVersion.*; + +public class ForgeDummyContainer extends DummyModContainer +{ + public ForgeDummyContainer() + { + super(new ModMetadata()); + ModMetadata meta = getMetadata(); + meta.modId = "Forge"; + meta.name = "Minecraft Forge"; + meta.version = String.format("%d.%d.%d.%d", majorVersion, minorVersion, revisionVersion, buildVersion); + meta.credits = "Made possible with help from many people"; + meta.authorList = Arrays.asList("LexManos", "Eloraam", "Spacetoad"); + meta.description = "Minecraft Forge is a common open source API allowing a broad range of mods " + + "to work cooperatively together. It allows many mods to be created without " + + "them editing the main Minecraft code."; + meta.url = "http://MinecraftForge.net"; + meta.updateUrl = "http://MinecraftForge.net/forum/index.php/topic,5.0.html"; + meta.screenshots = new String[0]; + meta.logoFile = "/forge_logo.png"; + } + + @Override + public boolean registerBus(EventBus bus, LoadController controller) + { + return true; + } +} diff --git a/common/net/minecraftforge/common/ForgeVersion.java b/common/net/minecraftforge/common/ForgeVersion.java new file mode 100644 index 0000000000..caf1574ece --- /dev/null +++ b/common/net/minecraftforge/common/ForgeVersion.java @@ -0,0 +1,44 @@ +/** + * This software is provided under the terms of the Minecraft Forge Public + * License v1.0. + */ + +package net.minecraftforge.common; + +public class ForgeVersion +{ + //This number is incremented every Minecraft version, and never reset + public static final int majorVersion = 4; + //This number is incremented every official release, and reset every Minecraft version + public static final int minorVersion = 0; + //This number is incremented every time a interface changes, and reset every Minecraft version + public static final int revisionVersion = 0; + //This number is incremented every time Jenkins builds Forge, and never reset. Should always be 0 in the repo code. + public static final int buildVersion = 0; + + public static int getMajorVersion() + { + return majorVersion; + } + + public static int getMinorVersion() + { + return minorVersion; + } + + public static int getRevisionVersion() + { + return revisionVersion; + } + + public static int getBuildVersion() + { + return buildVersion; + } + + public static String getVersion() + { + return String.format("%d.%d.%d.%d", majorVersion, minorVersion, revisionVersion, buildVersion); + } +} + diff --git a/common/net/minecraftforge/common/MinecraftForge.java b/common/net/minecraftforge/common/MinecraftForge.java new file mode 100644 index 0000000000..f576a29486 --- /dev/null +++ b/common/net/minecraftforge/common/MinecraftForge.java @@ -0,0 +1,8 @@ +package net.minecraftforge.common; + +import net.minecraftforge.event.EventBus; + +public class MinecraftForge +{ + public static final EventBus eventBus = new EventBus(); +} diff --git a/common/net/minecraftforge/event/ASMEventHandler.java b/common/net/minecraftforge/event/ASMEventHandler.java new file mode 100644 index 0000000000..fdddb3993e --- /dev/null +++ b/common/net/minecraftforge/event/ASMEventHandler.java @@ -0,0 +1,119 @@ +package net.minecraftforge.event; + +import static org.objectweb.asm.Opcodes.*; + +import java.lang.reflect.Method; + + +import org.objectweb.asm.ClassWriter; +import org.objectweb.asm.MethodVisitor; +import org.objectweb.asm.Type; + + +public class ASMEventHandler implements IEventListener +{ + private static int IDs = 0; + private static final String HANDLER_DESC = Type.getInternalName(IEventListener.class); + private static final String HANDLER_FUNC_DESC = Type.getMethodDescriptor(IEventListener.class.getDeclaredMethods()[0]); + private static final ASMClassLoader LOADER = new ASMClassLoader(); + + private final IEventListener handler; + private final ForgeSubscribe subInfo; + public ASMEventHandler(Object target, Method method) throws Exception + { + handler = (IEventListener)createWrapper(method).getConstructor(Object.class).newInstance(target); + subInfo = method.getAnnotation(ForgeSubscribe.class); + } + + @Override + public void invoke(Event event) + { + if (handler != null) + { + if (!event.isCancelable() || !event.isCanceled() || subInfo.receiveCanceled()) + { + handler.invoke(event); + } + } + } + + public EventPriority getPriority() + { + return subInfo.priority(); + } + + public Class createWrapper(Method callback) + { + ClassWriter cw = new ClassWriter(0); + MethodVisitor mv; + + String name = getUniqueName(callback); + String desc = name.replace('.', '/'); + String instType = Type.getInternalName(callback.getDeclaringClass()); + String eventType = Type.getInternalName(callback.getParameterTypes()[0]); + + /* + System.out.println("Name: " + name); + System.out.println("Desc: " + desc); + System.out.println("InstType: " + instType); + System.out.println("Callback: " + callback.getName() + Type.getMethodDescriptor(callback)); + System.out.println("Event: " + eventType); + */ + + cw.visit(V1_6, ACC_PUBLIC | ACC_SUPER, desc, null, "java/lang/Object", new String[]{ HANDLER_DESC }); + + cw.visitSource(".dynamic", null); + { + cw.visitField(ACC_PUBLIC, "instance", "Ljava/lang/Object;", null, null).visitEnd(); + } + { + mv = cw.visitMethod(ACC_PUBLIC, "", "(Ljava/lang/Object;)V", null, null); + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitMethodInsn(INVOKESPECIAL, "java/lang/Object", "", "()V"); + mv.visitVarInsn(ALOAD, 0); + mv.visitVarInsn(ALOAD, 1); + mv.visitFieldInsn(PUTFIELD, desc, "instance", "Ljava/lang/Object;"); + mv.visitInsn(RETURN); + mv.visitMaxs(2, 2); + mv.visitEnd(); + } + { + mv = cw.visitMethod(ACC_PUBLIC, "invoke", HANDLER_FUNC_DESC, null, null); + mv.visitCode(); + mv.visitVarInsn(ALOAD, 0); + mv.visitFieldInsn(GETFIELD, desc, "instance", "Ljava/lang/Object;"); + mv.visitTypeInsn(CHECKCAST, instType); + mv.visitVarInsn(ALOAD, 1); + mv.visitTypeInsn(CHECKCAST, eventType); + mv.visitMethodInsn(INVOKEVIRTUAL, instType, callback.getName(), Type.getMethodDescriptor(callback)); + mv.visitInsn(RETURN); + mv.visitMaxs(2, 2); + mv.visitEnd(); + } + cw.visitEnd(); + return LOADER.define(name, cw.toByteArray()); + } + + private String getUniqueName(Method callback) + { + return String.format("%s_%d_%s_%s_%s", getClass().getName(), IDs++, + callback.getDeclaringClass().getSimpleName(), + callback.getName(), + callback.getParameterTypes()[0].getSimpleName()); + } + + private static class ASMClassLoader extends ClassLoader + { + private ASMClassLoader() + { + super(ASMClassLoader.class.getClassLoader()); + } + + public Class define(String name, byte[] data) + { + return defineClass(name, data, 0, data.length); + } + } + +} diff --git a/common/net/minecraftforge/event/Event.java b/common/net/minecraftforge/event/Event.java new file mode 100644 index 0000000000..ca41c22fad --- /dev/null +++ b/common/net/minecraftforge/event/Event.java @@ -0,0 +1,70 @@ +package net.minecraftforge.event; + + +/** + * Base Event class that all other events are derived from + */ +public class Event +{ + private boolean isCanceled = false; + private static ListenerList listeners = new ListenerList(); + + public Event() + { + setup(); + } + + /** + * Determine if this function is cancelable at all. + * @return If access to setCanceled should be allowed + */ + public boolean isCancelable() + { + return false; + } + + /** + * Determine if this event is canceled and should stop executing. + * @return The current canceled state + */ + public boolean isCanceled() + { + return isCanceled; + } + + /** + * Sets the state of this event, not all events are cancelable, and any attempt to + * cancel a event that can't be will result in a IllegalArgumentException. + * + * The functionality of setting the canceled state is defined on a per-event bases. + * + * @param cancel The new canceled value + */ + public void setCanceled(boolean cancel) + { + if (!isCancelable()) + { + throw new IllegalArgumentException("Attempted to cancel a uncancelable event"); + } + isCanceled = cancel; + } + + /** + * Called by the base constructor, this is used by ASM generated + * event classes to setup various functionality such as the listener's list. + */ + protected void setup() + { + } + + /** + * Returns a ListenerList object that contains all listeners + * that are registered to this event. + * + * @return Listener List + */ + public ListenerList getListenerList() + { + return listeners; + } +} diff --git a/common/net/minecraftforge/event/EventBus.java b/common/net/minecraftforge/event/EventBus.java new file mode 100644 index 0000000000..2855a8372f --- /dev/null +++ b/common/net/minecraftforge/event/EventBus.java @@ -0,0 +1,103 @@ +package net.minecraftforge.event; + +import java.lang.reflect.Method; +import java.util.ArrayList; +import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; + + + +import com.google.common.reflect.TypeToken; + +public class EventBus +{ + private static int maxID = 0; + + private ConcurrentHashMap> listeners = new ConcurrentHashMap>(); + private final int busID = maxID++; + + public EventBus() + { + ListenerList.resize(busID + 1); + } + + public void register(Object target) + { + Set> supers = TypeToken.of(target.getClass()).getTypes().rawTypes(); + for (Method method : target.getClass().getMethods()) + { + for (Class cls : supers) + { + try + { + Method real = cls.getDeclaredMethod(method.getName(), method.getParameterTypes()); + if (real.isAnnotationPresent(ForgeSubscribe.class)) + { + Class[] parameterTypes = method.getParameterTypes(); + if (parameterTypes.length != 1) + { + throw new IllegalArgumentException( + "Method " + method + " has @ForgeSubscribe annotation, but requires " + parameterTypes.length + + " arguments. Event handler methods must require a single argument." + ); + } + + Class eventType = parameterTypes[0]; + + if (!Event.class.isAssignableFrom(eventType)) + { + throw new IllegalArgumentException("Method " + method + " has @ForgeSubscribe annotation, but takes a argument that is not a Event " + eventType); + } + + register(eventType, target, method); + break; + } + } + catch (NoSuchMethodException e) + { + ; + } + } + } + } + + private void register(Class eventType, Object target, Method method) + { + try + { + Event event = (Event)eventType.newInstance(); + ASMEventHandler listener = new ASMEventHandler(target, method); + event.getListenerList().register(busID, listener.getPriority(), listener); + + ArrayList others = listeners.get(target); + if (others == null) + { + others = new ArrayList(); + listeners.put(target, others); + } + others.add(listener); + } + catch (Exception e) + { + e.printStackTrace(); + } + } + + public void unregister(Object object) + { + ArrayList list = listeners.remove(object); + for (IEventListener listener : list) + { + ListenerList.unregiterAll(busID, listener); + } + } + + public void post(Event event) + { + IEventListener[] listeners = event.getListenerList().getListeners(busID); + for (IEventListener listener : listeners) + { + listener.invoke(event); + } + } +} diff --git a/common/net/minecraftforge/event/EventPriority.java b/common/net/minecraftforge/event/EventPriority.java new file mode 100644 index 0000000000..74302900c6 --- /dev/null +++ b/common/net/minecraftforge/event/EventPriority.java @@ -0,0 +1,16 @@ +package net.minecraftforge.event; + +public enum EventPriority +{ + /*Priority of event listeners, listeners will be sorted with respect to this priority level. + * + * Note: + * Due to using a ArrayList in the ListenerList, + * these need to stay in a contiguous index starting at 0. {Default ordinal} + */ + HIGHEST, //First to execute + HIGH, + NORMAL, + LOW, + LOWEST //Last to execute +} diff --git a/common/net/minecraftforge/event/ForgeSubscribe.java b/common/net/minecraftforge/event/ForgeSubscribe.java new file mode 100644 index 0000000000..0a5ffd8c55 --- /dev/null +++ b/common/net/minecraftforge/event/ForgeSubscribe.java @@ -0,0 +1,15 @@ +package net.minecraftforge.event; + +import java.lang.annotation.Retention; +import java.lang.annotation.Target; + +import static java.lang.annotation.RetentionPolicy.*; +import static java.lang.annotation.ElementType.*; + +@Retention(value = RUNTIME) +@Target(value = METHOD) +public @interface ForgeSubscribe +{ + public EventPriority priority() default EventPriority.NORMAL; + public boolean receiveCanceled() default false; +} diff --git a/common/net/minecraftforge/event/IEventListener.java b/common/net/minecraftforge/event/IEventListener.java new file mode 100644 index 0000000000..9fdd7f481f --- /dev/null +++ b/common/net/minecraftforge/event/IEventListener.java @@ -0,0 +1,8 @@ +package net.minecraftforge.event; + + + +public interface IEventListener +{ + public void invoke(Event event); +} diff --git a/common/net/minecraftforge/event/ListenerList.java b/common/net/minecraftforge/event/ListenerList.java new file mode 100644 index 0000000000..b88a4c86e7 --- /dev/null +++ b/common/net/minecraftforge/event/ListenerList.java @@ -0,0 +1,211 @@ +package net.minecraftforge.event; + +import java.util.*; + + +public class ListenerList +{ + private static ArrayList allLists = new ArrayList(); + private static int maxSize = 0; + + private ListenerList parent; + private ListenerListInst[] lists = new ListenerListInst[0]; + + public ListenerList() + { + allLists.add(this); + resizeLists(maxSize); + } + + public ListenerList(ListenerList parent) + { + allLists.add(this); + this.parent = parent; + resizeLists(maxSize); + } + + public static void resize(int max) + { + if (max <= maxSize) + { + return; + } + for (ListenerList list : allLists) + { + list.resizeLists(max); + } + maxSize = max; + } + + public void resizeLists(int max) + { + if (parent != null) + { + parent.resizeLists(max); + } + + if (lists.length >= max) + { + return; + } + + ListenerListInst[] newList = new ListenerListInst[max]; + int x = 0; + for (; x < lists.length; x++) + { + newList[x] = lists[x]; + } + for(; x < max; x++) + { + if (parent != null) + { + newList[x] = new ListenerListInst(parent.getInstance(x)); + } + else + { + newList[x] = new ListenerListInst(); + } + } + lists = newList; + } + + public static void clearBusID(int id) + { + for (ListenerList list : allLists) + { + list.lists[id].dispose(); + } + } + + protected ListenerListInst getInstance(int id) + { + return lists[id]; + } + + public IEventListener[] getListeners(int id) + { + return lists[id].getListeners(); + } + + public void register(int id, EventPriority priority, IEventListener listener) + { + lists[id].register(priority, listener); + } + + public void unregister(int id, IEventListener listener) + { + lists[id].unregister(listener); + } + + public static void unregiterAll(int id, IEventListener listener) + { + for (ListenerList list : allLists) + { + list.unregister(id, listener); + } + } + + private class ListenerListInst + { + private boolean rebuild = true; + private IEventListener[] listeners; + private ArrayList> priorities; + private ListenerListInst parent; + + private ListenerListInst() + { + int count = EventPriority.values().length; + priorities = new ArrayList>(count); + + for (int x = 0; x < count; x++) + { + priorities.add(new ArrayList()); + } + } + + public void dispose() + { + for (ArrayList listeners : priorities) + { + listeners.clear(); + } + priorities.clear(); + parent = null; + listeners = null; + } + + private ListenerListInst(ListenerListInst parent) + { + this(); + this.parent = parent; + } + + /** + * Returns a ArrayList containing all listeners for this event, + * and all parent events for the specified priority. + * + * The list is returned with the listeners for the children events first. + * + * @param priority The Priority to get + * @return ArrayList containing listeners + */ + public ArrayList getListeners(EventPriority priority) + { + ArrayList ret = new ArrayList(priorities.get(priority.ordinal())); + if (parent != null) + { + ret.addAll(parent.getListeners(priority)); + } + return ret; + } + + /** + * Returns a full list of all listeners for all priority levels. + * Including all parent listeners. + * + * List is returned in proper priority order. + * + * Automatically rebuilds the internal Array cache if its information is out of date. + * + * @return Array containing listeners + */ + public IEventListener[] getListeners() + { + if (shouldRebuild()) buildCache(); + return listeners; + } + + protected boolean shouldRebuild() + { + return rebuild || (parent != null && parent.shouldRebuild()); + } + + /** + * Rebuild the local Array of listeners, returns early if there is no work to do. + */ + private void buildCache() + { + ArrayList ret = new ArrayList(); + for (EventPriority value : EventPriority.values()) + { + ret.addAll(getListeners(value)); + } + listeners = ret.toArray(new IEventListener[0]); + rebuild = false; + } + + public void register(EventPriority priority, IEventListener listener) + { + priorities.get(priority.ordinal()).add(listener); + rebuild = true; + } + + public void unregister(IEventListener listener) + { + for(ArrayList list : priorities) + { + list.remove(listener); + } + } + } +} diff --git a/common/net/minecraftforge/transformers/EventTransformer.java b/common/net/minecraftforge/transformers/EventTransformer.java new file mode 100644 index 0000000000..07b5cf8f92 --- /dev/null +++ b/common/net/minecraftforge/transformers/EventTransformer.java @@ -0,0 +1,132 @@ +package net.minecraftforge.transformers; + +import java.util.List; + +import net.minecraftforge.event.Event; +import net.minecraftforge.event.ListenerList; + +import org.objectweb.asm.*; +import org.objectweb.asm.tree.*; +import static org.objectweb.asm.Opcodes.*; +import static org.objectweb.asm.Type.*; +import static org.objectweb.asm.ClassWriter.*; + +import cpw.mods.fml.relauncher.IClassTransformer; + +public class EventTransformer implements IClassTransformer +{ + public EventTransformer() + { + } + + @Override + public byte[] transform(String name, byte[] bytes) + { + ClassReader cr = new ClassReader(bytes); + ClassNode classNode = new ClassNode(); + cr.accept(classNode, 0); + + try + { + buildEvents(classNode); + } + catch (Exception e) + { + e.printStackTrace(); + } + + ClassWriter cw = new ClassWriter(COMPUTE_MAXS | COMPUTE_FRAMES); + classNode.accept(cw); + + return cw.toByteArray(); + } + + @SuppressWarnings("unchecked") + private void buildEvents(ClassNode classNode) throws Exception + { + Class parent = Class.forName(classNode.superName.replace('/', '.')); + if (!Event.class.isAssignableFrom(parent)) + { + return; + } + + boolean hasSetup = false; + boolean hasGetListenerList = false; + + Type tList = Type.getType(ListenerList.class); + + for (MethodNode method : (List)classNode.methods) + { + if (method.name.equals("setup") && + method.desc.equals(Type.getMethodDescriptor(VOID_TYPE)) && + (method.access & ACC_PROTECTED) == ACC_PROTECTED) + { + hasSetup = true; + } + if (method.name.equals("getListenerList") && + method.desc.equals(Type.getMethodDescriptor(tList)) && + (method.access & ACC_PUBLIC) == ACC_PUBLIC) + { + hasGetListenerList = true; + } + } + + if (hasSetup) + { + if (!hasGetListenerList) + { + throw new RuntimeException("Event class defines setup() but does not define getListenerList! " + classNode.name); + } + else + { + return; + } + } + + Type tSuper = Type.getType(classNode.superName); + + //Add private static ListenerList LISTENER_LIST + classNode.fields.add(new FieldNode(ACC_PRIVATE | ACC_STATIC, "LISTENER_LIST", tList.getDescriptor(), null, null)); + + /*Add: + * protected void setup() + * { + * super.setup(); + * if (LISTENER_LIST != NULL) + * { + * return; + * } + * LISTENER_LIST = new ListenerList(super.getListenerList()); + * } + */ + MethodNode method = new MethodNode(ASM4, ACC_PROTECTED, "setup", getMethodDescriptor(VOID_TYPE), null, null); + method.instructions.add(new VarInsnNode(ALOAD, 0)); + method.instructions.add(new MethodInsnNode(INVOKESPECIAL, tSuper.getInternalName(), "setup", getMethodDescriptor(VOID_TYPE))); + method.instructions.add(new FieldInsnNode(GETSTATIC, classNode.name, "LISTENER_LIST", tList.getDescriptor())); + LabelNode initLisitener = new LabelNode(); + method.instructions.add(new JumpInsnNode(IFNULL, initLisitener)); + method.instructions.add(new InsnNode(RETURN)); + method.instructions.add(initLisitener); + method.instructions.add(new FrameNode(F_SAME, 0, null, 0, null)); + method.instructions.add(new TypeInsnNode(NEW, tList.getInternalName())); + method.instructions.add(new InsnNode(DUP)); + method.instructions.add(new VarInsnNode(ALOAD, 0)); + method.instructions.add(new MethodInsnNode(INVOKESPECIAL, tSuper.getInternalName(), "getListenerList", getMethodDescriptor(tList))); + method.instructions.add(new MethodInsnNode(INVOKESPECIAL, tList.getInternalName(), "", getMethodDescriptor(VOID_TYPE, tList))); + method.instructions.add(new FieldInsnNode(PUTSTATIC, classNode.name, "LISTENER_LIST", tList.getDescriptor())); + method.instructions.add(new InsnNode(RETURN)); + classNode.methods.add(method); + + /*Add: + * public ListenerList getListenerList() + * { + * return this.LISTENER_LIST; + * } + */ + method = new MethodNode(ASM4, ACC_PUBLIC, "getListenerList", getMethodDescriptor(tList), null, null); + method.instructions.add(new FieldInsnNode(GETSTATIC, classNode.name, "LISTENER_LIST", tList.getDescriptor())); + method.instructions.add(new InsnNode(ARETURN)); + classNode.methods.add(method); + } + +} diff --git a/common/net/minecraftforge/transformers/ForgeAccessTransformer.java b/common/net/minecraftforge/transformers/ForgeAccessTransformer.java new file mode 100644 index 0000000000..810d950069 --- /dev/null +++ b/common/net/minecraftforge/transformers/ForgeAccessTransformer.java @@ -0,0 +1,13 @@ +package net.minecraftforge.transformers; + +import java.io.IOException; + +import cpw.mods.fml.common.asm.transformers.AccessTransformer; + +public class ForgeAccessTransformer extends AccessTransformer +{ + public ForgeAccessTransformer() throws IOException + { + super("forge_at.cfg"); + } +} diff --git a/forge_client/src/net/minecraft/src/forge/EnumHelperClient.java b/forge_client/src/net/minecraft/src/forge/EnumHelperClient.java deleted file mode 100644 index e552428461..0000000000 --- a/forge_client/src/net/minecraft/src/forge/EnumHelperClient.java +++ /dev/null @@ -1,106 +0,0 @@ -package net.minecraft.src.forge; - -import argo.jdom.JsonNodeType; -import net.minecraft.src.EnumOS2; -import net.minecraft.src.EnumOptions; -import net.minecraft.src.EnumRarity; - -public class EnumHelperClient extends EnumHelper -{ - - private static Class[][] ctrs = - { - {JsonNodeType.class}, - {EnumOptions.class, String.class, boolean.class, boolean.class}, - {EnumOS2.class}, - {EnumRarity.class, int.class, String.class} - }; - - private static boolean[] decompiled = new boolean[ctrs.length]; - private static boolean isSetup = false; - - public static JsonNodeType addJsonNodeType(String name) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiled[0], JsonNodeType.class, name, - new Class[] {}, - new Object[] {}); - } - public static EnumOptions addOptions(String name, String langName, boolean isSlider, boolean isToggle) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiled[1], EnumOptions.class, name, - new Class[] {String.class, boolean.class, boolean.class}, - new Object[]{langName, isSlider, isToggle }); - } - public static EnumOS2 addOS2(String name) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiled[2], EnumOS2.class, name, - new Class[] {}, - new Object[]{}); - } - public static EnumRarity addRarity(String name, int color, String displayName) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiled[3], EnumRarity.class, name, - new Class[] {int.class, String.class}, - new Object[]{color, displayName }); - } - - private static void setup() - { - //System.out.println("Enum Helper Initalizing: "); - for (int x = 0; x < ctrs.length; x++) - { - try - { - Class[] enumHeaders = new Class[ctrs[x].length + 3]; - enumHeaders[0] = String.class; - enumHeaders[1] = int.class; - enumHeaders[2] = String.class; - enumHeaders[3] = int.class; - - for (int y = 1; y < ctrs[x].length; y++) - { - enumHeaders[3 + y] = ctrs[x][y]; - } - - ctrs[x][0].getDeclaredConstructor(enumHeaders); - decompiled[x] = true; - - } - catch (Exception e) - { - //Nom Nom Nom - } - //System.out.format("\t%-25s %s\r\n", ctrs[x][0].getName().replace("net.minecraft.src.", ""), decompiled[x]); - } - isSetup = true; - } - - static - { - if (!isSetup) - { - setup(); - } - } - -} diff --git a/forge_common/net/minecraft/src/forge/EnumHelper.java b/forge_common/net/minecraft/src/forge/EnumHelper.java deleted file mode 100644 index 1b1e341fed..0000000000 --- a/forge_common/net/minecraft/src/forge/EnumHelper.java +++ /dev/null @@ -1,366 +0,0 @@ -package net.minecraft.src.forge; - -import net.minecraft.src.*; -import java.lang.reflect.*; -import java.util.*; - -public class EnumHelper -{ - private static Object reflectionFactory = null; - private static Method newConstructorAccessor = null; - private static Method newInstance = null; - private static Method newFieldAccessor = null; - private static Method fieldAccessorSet = null; - private static boolean isSetup = false; - - //Some enums are decompiled with extra arguments, so lets check for that - private static Class[][] ctrs = - { - {EnumAction.class}, - {EnumArmorMaterial.class, int.class, int[].class, int.class}, - {EnumArt.class, String.class, int.class, int.class, int.class, int.class}, - {EnumCreatureAttribute.class}, - {EnumCreatureType.class, Class.class, int.class, Material.class, boolean.class}, - {EnumDoor.class}, - {EnumEnchantmentType.class}, - {EnumMobType.class}, - {EnumMovingObjectType.class}, - {EnumSkyBlock.class, int.class}, - {EnumStatus.class}, - {EnumToolMaterial.class, int.class, int.class, float.class, int.class, int.class} - }; - - private static boolean[] decompiledFlags = new boolean[ctrs.length]; - - public static EnumAction addAction(String name) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiledFlags[0], EnumAction.class, name, - new Class[] {}, - new Object[]{}); - } - public static EnumArmorMaterial addArmorMaterial(String name, int durability, int[] reductionAmounts, int enchantability) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiledFlags[1], EnumArmorMaterial.class, name, - new Class[] { int.class, int[].class, int.class }, - new Object[]{ durability, reductionAmounts, enchantability }); - } - public static EnumArt addArt(String name, String tile, int sizeX, int sizeY, int offsetX, int offsetY) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiledFlags[2], EnumArt.class, name, - new Class[] {String.class, int.class, int.class, int.class, int.class}, - new Object[]{tile, sizeX, sizeY, offsetX, offsetY}); - } - public static EnumCreatureAttribute addCreatureAttribute(String name) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiledFlags[3], EnumCreatureAttribute.class, name, - new Class[] {}, - new Object[]{}); - } - public static EnumCreatureType addCreatureType(String name, Class typeClass, int maxNumber, Material material, boolean peaceful) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiledFlags[4], EnumCreatureType.class, name, - new Class[] {Class.class, int.class, Material.class, boolean.class}, - new Object[]{typeClass, maxNumber, material, peaceful}); - } - public static EnumDoor addDoor(String name) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiledFlags[5], EnumDoor.class, name, - new Class[] {}, - new Object[]{}); - } - public static EnumEnchantmentType addEnchantmentType(String name) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiledFlags[6], EnumEnchantmentType.class, name, - new Class[] {}, - new Object[]{}); - } - public static EnumMobType addMobType(String name) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiledFlags[7], EnumMobType.class, name, - new Class[] {}, - new Object[]{}); - } - public static EnumMovingObjectType addMovingObjectType(String name) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiledFlags[8], EnumMovingObjectType.class, name, - new Class[] {}, - new Object[]{}); - } - public static EnumSkyBlock addSkyBlock(String name, int lightValue) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiledFlags[9], EnumSkyBlock.class, name, - new Class[] {int.class }, - new Object[]{lightValue}); - } - public static EnumStatus addStatus(String name) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiledFlags[10], EnumStatus.class, name, - new Class[] {}, - new Object[]{}); - } - public static EnumToolMaterial addToolMaterial(String name, int harvestLevel, int maxUses, float efficiency, int damage, int enchantability) - { - if (!isSetup) - { - setup(); - } - - return addEnum(decompiledFlags[11], EnumToolMaterial.class, name, - new Class[] { int.class, int.class, float.class, int.class, int.class }, - new Object[]{ harvestLevel, maxUses, efficiency, damage, enchantability }); - } - - private static void setup() - { - if (isSetup) - { - return; - } - - //System.out.println("Enum Helper Initalizing: "); - for (int x = 0; x < ctrs.length; x++) - { - try - { - Class[] enumHeaders = new Class[ctrs[x].length + 3]; - enumHeaders[0] = String.class; - enumHeaders[1] = int.class; - enumHeaders[2] = String.class; - enumHeaders[3] = int.class; - - for (int y = 1; y < ctrs[x].length; y++) - { - enumHeaders[3 + y] = ctrs[x][y]; - } - - ctrs[x][0].getDeclaredConstructor(enumHeaders); - decompiledFlags[x] = true; - - } - catch (Exception e) - { - //Nom Nom Nom - } - //System.out.format("\t%-25s %s\r\n", ctrs[x][0].getName().replace("net.minecraft.src.", ""), decompiled[x]); - } - - - - try - { - Method getReflectionFactory = Class.forName("sun.reflect.ReflectionFactory").getDeclaredMethod("getReflectionFactory"); - reflectionFactory = getReflectionFactory.invoke(null); - newConstructorAccessor = Class.forName("sun.reflect.ReflectionFactory").getDeclaredMethod("newConstructorAccessor", Constructor.class); - newInstance = Class.forName("sun.reflect.ConstructorAccessor").getDeclaredMethod("newInstance", Object[].class); - newFieldAccessor = Class.forName("sun.reflect.ReflectionFactory").getDeclaredMethod("newFieldAccessor", Field.class, boolean.class); - fieldAccessorSet = Class.forName("sun.reflect.FieldAccessor").getDeclaredMethod("set", Object.class, Object.class); - } - catch (Exception e) - { - e.printStackTrace(); - } - - isSetup = true; - } - - - /* - * Everything below this is found at the site below, and updated to be able to compile in Eclipse/Java 1.6+ - * Also modified for use in decompiled code. - * Found at: http://niceideas.ch/roller2/badtrash/entry/java_create_enum_instances_dynamically - */ - - private static Object getConstructorAccessor(boolean decompiled, Class enumClass, Class[] additionalParameterTypes) throws Exception - { - Class[] parameterTypes = null; - if (decompiled) - { - parameterTypes = new Class[additionalParameterTypes.length + 4]; - parameterTypes[0] = String.class; - parameterTypes[1] = int.class; - parameterTypes[2] = String.class; - parameterTypes[3] = int.class; - System.arraycopy(additionalParameterTypes, 0, parameterTypes, 4, additionalParameterTypes.length); - } - else - { - parameterTypes = new Class[additionalParameterTypes.length + 2]; - parameterTypes[0] = String.class; - parameterTypes[1] = int.class; - System.arraycopy(additionalParameterTypes, 0, parameterTypes, 2, additionalParameterTypes.length); - } - return newConstructorAccessor.invoke(reflectionFactory, enumClass.getDeclaredConstructor(parameterTypes)); - } - - private static < T extends Enum> T makeEnum(boolean decompiled, Class enumClass, String value, int ordinal, Class[] additionalTypes, Object[] additionalValues) throws Exception - { - Object[] parms = null; - if (decompiled) - { - parms = new Object[additionalValues.length + 4]; - parms[0] = value; - parms[1] = Integer.valueOf(ordinal); - parms[2] = value; - parms[3] = Integer.valueOf(ordinal); - System.arraycopy(additionalValues, 0, parms, 4, additionalValues.length); - } - else - { - parms = new Object[additionalValues.length + 2]; - parms[0] = value; - parms[1] = Integer.valueOf(ordinal); - System.arraycopy(additionalValues, 0, parms, 2, additionalValues.length); - } - return enumClass.cast(newInstance.invoke(getConstructorAccessor(decompiled, enumClass, additionalTypes), new Object[] {parms})); - } - - public static void setFailsafeFieldValue(Field field, Object target, Object value) throws Exception - { - field.setAccessible(true); - Field modifiersField = Field.class.getDeclaredField("modifiers"); - modifiersField.setAccessible(true); - modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL); - Object fieldAccessor = newFieldAccessor.invoke(reflectionFactory, field, false); - fieldAccessorSet.invoke(fieldAccessor, target, value); - } - - private static void blankField(Class enumClass, String fieldName) throws Exception - { - for (Field field : Class.class.getDeclaredFields()) - { - if (field.getName().contains(fieldName)) - { - field.setAccessible(true); - setFailsafeFieldValue(field, enumClass, null); - break; - } - } - } - - private static void cleanEnumCache(Class enumClass) throws Exception - { - blankField(enumClass, "enumConstantDirectory"); - blankField(enumClass, "enumConstants"); - } - - public static < T extends Enum> T addEnum(Class enumType, String enumName, boolean decompiled) - { - return addEnum(decompiled, enumType, enumName, new Class[] {}, new Object[] {}); - } - - @SuppressWarnings("unchecked") - public static > T addEnum(boolean decompiled, Class enumType, String enumName, Class[] paramTypes, Object[] paramValues) - { - if (!isSetup) - { - setup(); - } - - Field valuesField = null; - Field[] fields = enumType.getDeclaredFields(); - int flags = Modifier.PRIVATE | Modifier.STATIC | Modifier.FINAL | 0x1000 /*SYNTHETIC*/; - String valueType = String.format("[L%s;", enumType.getName().replace('.', '/')); - - for (Field field : fields) - { - if (decompiled) - { - if (field.getName().contains("$VALUES")) - { - valuesField = field; - break; - } - } - else - { - if ((field.getModifiers() & flags) == flags && - field.getType().getName().replace('.', '/').equals(valueType)) //Apparently some JVMs return .'s and some don't.. - { - valuesField = field; - break; - } - } - } - valuesField.setAccessible(true); - - try - { - T[] previousValues = (T[])valuesField.get(enumType); - List values = new ArrayList(Arrays.asList(previousValues)); - T newValue = (T)makeEnum(decompiled, enumType, enumName, values.size(), paramTypes, paramValues); - values.add(newValue); - setFailsafeFieldValue(valuesField, null, values.toArray((T[]) Array.newInstance(enumType, 0))); - cleanEnumCache(enumType); - - return newValue; - } - catch (Exception e) - { - e.printStackTrace(); - throw new RuntimeException(e.getMessage(), e); - } - } - - static - { - if (!isSetup) - { - setup(); - } - } -} \ No newline at end of file