public class EDFMLLoadingPlugin implements IFMLLoadingPlugin {

@Override
public String[] getASMTransformerClass() {
//This will return the name of the class "mod.culegooner.EDClassTransformer"
return new String[]{EDClassTransformer.class.getName()};
}
}

public class EDClassTransformer implements IClassTransformer {

@Override
public byte[] transform(String arg0, String arg1, byte[] arg2) {
//Bytecode manipulations goes here
}

public byte[] transform(String arg0, String arg1, byte[] arg2) {

@Override
public byte[] transform(String arg0, String arg1, byte[] arg2) {

if (arg0.equals("abq")) {
System.out.println("********* INSIDE OBFUSCATED EXPLOSION TRANSFORMER ABOUT TO PATCH: " + arg0);
return patchClassASM(arg0, arg2, true);
}

if (arg0.equals("net.minecraft.world.Explosion")) {
System.out.println("********* INSIDE EXPLOSION TRANSFORMER ABOUT TO PATCH: " + arg0);
return patchClassASM(arg0, arg2, false);
}

return arg2;
}

public void doExplosionB(boolean par1)

var25.dropBlockAsItemWithChance(this.worldObj, var4, var5, var6, this.worldObj.getBlockMetadata(var4, var5, var6), 1.0F / this.explosionSize, 0);

var25.dropBlockAsItemWithChance(this.worldObj, var4, var5, var6, this.worldObj.getBlockMetadata(var4, var5, var6), 1.0F, 0);

mv.visitInsn(FCONST_1);
mv.visitVarInsn(ALOAD, 0);
mv.visitFieldInsn(GETFIELD, "net/minecraft/src/Explosion", "explosionSize", "F");
mv.visitInsn(FDIV);
mv.visitInsn(ICONST_0);
mv.visitMethodInsn(INVOKEVIRTUAL, "net/minecraft/src/Block", "dropBlockAsItemWithChance", "(Lnet/minecraft/src/World;IIIIFI)V");

public byte[] patchClassASM(String name, byte[] bytes, boolean obfuscated) {

String targetMethodName = "";

//Our target method
if(obfuscated == true)
targetMethodName ="a";
else
targetMethodName ="doExplosionB";


//set up ASM class manipulation stuff. Consult the ASM docs for details
ClassNode classNode = new ClassNode();
ClassReader classReader = new ClassReader(bytes);
classReader.accept(classNode, 0);

//Now we loop over all of the methods declared inside the Explosion class until we get to the targetMethodName "doExplosionB"

Iterator<MethodNode> methods = classNode.methods.iterator();
while(methods.hasNext())
{
MethodNode m = methods.next();
int fdiv_index = -1;

//Check if this is doExplosionB and it's method signature is (Z)V which means that it accepts a boolean (Z) and returns a void (V)
if ((m.name.equals(targetMethodName) && m.desc.equals("(Z)V")))
{
System.out.println("********* Inside target method!");

AbstractInsnNode currentNode = null;
AbstractInsnNode targetNode = null;

@SuppressWarnings("unchecked")
Iterator<AbstractInsnNode> iter = m.instructions.iterator();

int index = -1;

//Loop over the instruction set and find the instruction FDIV which does the division of 1/explosionSize
while (iter.hasNext())
{
index++;
currentNode = iter.next();

//Found it! save the index location of instruction FDIV and the node for this instruction
if (currentNode.getOpcode() == FDIV)
{
targetNode = currentNode;
fdiv_index = index;
}
}

//now we want the save nods that load the variable explosionSize and the division instruction:

/*
mv.visitInsn(FCONST_1);
mv.visitVarInsn(ALOAD, 0);
mv.visitFieldInsn(GETFIELD, "net/minecraft/src/Explosion", "explosionSize", "F");
mv.visitInsn(FDIV);
mv.visitInsn(ICONST_0);
mv.visitMethodInsn(INVOKEVIRTUAL, "net/minecraft/src/Block", "dropBlockAsItemWithChance", "(Lnet/minecraft/src/World;IIIIFI)V");
*/

AbstractInsnNode remNode1 = m.instructions.get(fdiv_index-2); // mv.visitVarInsn(ALOAD, 0);
AbstractInsnNode remNode2 = m.instructions.get(fdiv_index-1); // mv.visitFieldInsn(GETFIELD, "net/minecraft/src/Explosion", "explosionSize", "F");
AbstractInsnNode remNode3 = m.instructions.get(fdiv_index); // mv.visitInsn(FDIV);


//just remove these nodes from the instruction set, this will prevent the instruction FCONST_1 to be divided.

m.instructions.remove(remNode1);
m.instructions.remove(remNode2);
m.instructions.remove(remNode3);


//in this section, i'll just illustrate how to inject a call to a static method if your instruction is a little more advanced than just removing a couple of instruction:

/*
To add new instructions, such as calling a static method can be done like so:

// make new instruction list
InsnList toInject = new InsnList();

//add your own instruction lists: *USE THE ASM JAVADOC AS REFERENCE*
toInject.add(new VarInsnNode(ALOAD, 0));
toInject.add(new MethodInsnNode(INVOKESTATIC, "mod/culegooner/MyStaticClass", "myStaticMethod", "()V"));

// add the added code to the nstruction list
// You can also choose if you want to add the code before or after the target node, check the ASM Javadoc (insertBefore)
m.instructions.insert(targetNode, toInject);
*/

System.out.println("Patching Complete!");
break;
}
}

//ASM specific for cleaning up and returning the final bytes for JVM processing.
ClassWriter writer = new ClassWriter(ClassWriter.COMPUTE_MAXS | ClassWriter.COMPUTE_FRAMES);
classNode.accept(writer);
return writer.toByteArray();
}

diff -ruN forge/mcp/src/minecraft/net/minecraft/entity/monster/EntityCreeper.java baseEdits_777/mcp/src/minecraft/net/minecraft/entity/monster/EntityCreeper.java
--- forge/mcp/src/minecraft/net/minecraft/entity/monster/EntityCreeper.java 2013-07-09 03:42:53.130368000 +0300
+++ baseEdits_777/mcp/src/minecraft/net/minecraft/entity/monster/EntityCreeper.java 2013-07-09 04:30:41.259006500 +0300
@@ -19,6 +19,7 @@
import net.minecraft.item.Item;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.util.DamageSource;
+import net.minecraft.util.MathHelper;
import net.minecraft.world.World;

public class EntityCreeper extends EntityMob
@@ -259,4 +260,25 @@
super.onStruckByLightning(par1EntityLightningBolt);
this.dataWatcher.updateObject(17, Byte.valueOf((byte)1));
}
+
+
+ /**
+ * Called frequently so the entity can update its state every tick as required. For example, zombies and skeletons
+ * use this to react to sunlight and start to burn.
+ */
+ public void onLivingUpdate()
+ {
+ if (this.worldObj.isDaytime() && !this.worldObj.isRemote)
+ {
+ float f = this.getBrightness(1.0F);
+
+ if (f > 0.5F && this.rand.nextFloat() * 30.0F < (f - 0.4F) * 2.0F && this.worldObj.canBlockSeeTheSky(MathHelper.floor_double(this.posX), MathHelper.floor_double(this.posY), MathHelper.floor_double(this.posZ)))
+ {
+ this.setFire(8);
+ }
+ }
+
+ super.onLivingUpdate();
+ }
+
}

CreeperBurnCore_dummy.jar
+->META-INF
..|
..+-> MANIFEST.MF

+->net
..|
..+->minecraft
....|
....+->entity
......|
......+->monster
........|
........+->EntityCreeper.class

+->te.class

public class CBFMLLoadingPlugin implements IFMLLoadingPlugin {

//declare a placeholder for the name and location of the CreeperBurnCore_dummy.jar
public static File location;

@Override
public String[] getASMTransformerClass() {
////This will return the name of the class "mod.culegooner.CBClassTransformer"
return new String[]{CBClassTransformer.class.getName()};
}


@Override
public void injectData(Map<String, Object> data) {
//This will return the jar file of this mod CreeperBurnCore_dummy.jar"
location = (File) data.get("coremodLocation");
}

}

public class CBClassTransformer implements IClassTransformer {

@Override
public byte[] transform(String arg0, String arg1, byte[] arg2) {

//Check if the JVM is about to process the te.class or the EntityCreeper.class
if (arg0.equals("te") || arg0.equals("net.minecraft.entity.monster.EntityCreeper")) {
System.out.println("********* INSIDE CREEPER TRANSFORMER ABOUT TO PATCH: " + arg0);
arg2 = patchClassInJar(arg0, arg2, arg0, CBFMLLoadingPlugin.location);
}
return arg2;
}

//a small helper method that takes the class name we want to replace and our jar file.
//It then uses the java zip library to open up the jar file and extract the classes.
//Afterwards it serializes the class in bytes and pushes it on to the JVM.
//with the original bytes that JVM was about to process ignored completly

public byte[] patchClassInJar(String name, byte[] bytes, String ObfName, File location) {
try {
//open the jar as zip
ZipFile zip = new ZipFile(location);
//find the file inside the zip that is called te.class or net.minecraft.entity.monster.EntityCreeper.class
//replacing the . to / so it would look for net/minecraft/entity/monster/EntityCreeper.class
ZipEntry entry = zip.getEntry(name.replace('.', '/') + ".class");


if (entry == null) {
System.out.println(name + " not found in " + location.getName());
} else {

//serialize the class file into the bytes array
InputStream zin = zip.getInputStream(entry);
bytes = new byte[(int) entry.getSize()];
zin.read(bytes);
zin.close();
System.out.println("[" + "CreeperBurnCore" + "]: " + "Class " + name + " patched!");
}
zip.close();
} catch (Exception e) {
throw new RuntimeException("Error overriding " + name + " from " + location.getName(), e);
}

//return the new bytes
return bytes;
}
}

@Override
public String getModContainerClass() {
//This is the name of our dummy container "mod.culegooner.CreeperBurnCore.CBDummyContainer"
return CBDummyContainer.class.getName();
}

package mod.culegooner.CreeperBurnCore;

import java.util.Arrays;

import com.google.common.eventbus.EventBus;
import com.google.common.eventbus.Subscribe;

import cpw.mods.fml.common.DummyModContainer;
import cpw.mods.fml.common.LoadController;
import cpw.mods.fml.common.ModMetadata;
import cpw.mods.fml.common.event.FMLConstructionEvent;
import cpw.mods.fml.common.event.FMLInitializationEvent;
import cpw.mods.fml.common.event.FMLPostInitializationEvent;
import cpw.mods.fml.common.event.FMLPreInitializationEvent;

public class CBDummyContainer extends DummyModContainer {

public CBDummyContainer() {

super(new ModMetadata());
ModMetadata meta = getMetadata();
meta.modId = "CreeperBurnCore";
meta.name = "CreeperBurnCore";
meta.version = "@VERSION@";
meta.credits = "Roll Credits ...";
meta.authorList = Arrays.asList("culegooner");
meta.description = "";
meta.url = "https://github.com/culegooner/CreeperBurnCore";
meta.updateUrl = "";
meta.screenshots = new String[0];
meta.logoFile = "";

}

@Override
public boolean registerBus(EventBus bus, LoadController controller) {
bus.register(this);
return true;
}

@Subscribe
public void modConstruction(FMLConstructionEvent evt){

}

@Subscribe
public void preInit(FMLPreInitializationEvent evt) {

}

@Subscribe
public void init(FMLInitializationEvent evt) {

}


@Subscribe
public void postInit(FMLPostInitializationEvent evt) {

}

}

-Dfml.coreMods.load=mod.culegooner.ExplosionDropsCore.EDFMLLoadingPlugin

Manifest-Version: 1.0
FMLCorePlugin: mod.culegooner.ExplosionDropsCore.EDFMLLoadingPlugin
Created-By: 1.7.0 (Oracle Corporation)

ExplosionDropsCore_dummy.jar
+->META-INF
..|
..+-> MANIFEST.MF

private int var;

public int var;

public class FMLForgePlugin implements IFMLLoadingPlugin
{
@Override
public String[] getASMTransformerClass()
{
return new String[]{"net.minecraftforge.transformers.ForgeAccessTransformer"}; }
}

public class ForgeAccessTransformer extends AccessTransformer
{
public ForgeAccessTransformer() throws IOException
{
super("forge_at.cfg");
}
}

# CallableMinecraftVersion - sanity check the MC version
public c #CL:CallableMinecraftVersion
public c.<init>(Lb;)V #MD:CallableMinecraftVersion/<init>(Lnet/minecraft/src/CrashReport;) #constructor

javap -s c.class

Compiled from "SourceFile"
class c implements java.util.concurrent.Callable {
final b a;
Signature: Lb;
c(B);
Signature: (Lb;)V

public java.lang.String a();
Signature: ()Ljava/lang/String;

public java.lang.Object call();
Signature: ()Ljava/lang/Object;
}