Minecraft Forums

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;
}

@Init
public void modInit(FMLInitializationEvent event) {

/*
Register a new spawn egg for your entity as follows.
TutZombie.class is the class of the entity which we will create later on. "TutZombie" is the name of the entity and the random numbers at the end are the colors of the spawn egg.
*/
EntityRegistry.registerGlobalEntityID(TutZombie.class,"TutZombie",EntityRegistry.findGlobalUniqueEntityId(), 16733525, 10066431);
/*
Register the entity to be able to spawn it, once again the parameters are the class name, name of the entity, the ID of the entity and the mod that this entity comes from. the next two numbers are the tracking range and update frequency. I've checked so many mod to see what values they use and they appear random to say the least, i decided to stick with the numbers that thaumcraft uses for their angry zombies, 64 for the tracking with update frequency 3. the last parameter is the send velocity update parameter, again all of the mods that i looked at set it to true.
*/
EntityRegistry.registerModEntity(TutZombie.class, "TutZombie", 2, this, 64, 3, true);

/*
here we do the same thing over again for our new creeper entity
*/


EntityRegistry.registerGlobalEntityID(TutCreeper.class,"TutCreeper",EntityRegistry.findGlobalUniqueEntityId(), 6750105, 7859797);
EntityRegistry.registerModEntity(TutCreeper.class, "TutCreeper", 3, this, 64, 3, true);


/*
This is the most crucial part of the whole tutorial and where the bulk of the vanilla overriding will take place.
minecraft sends events whenever something happens (spawning, killing, dancing whatever) and what this allows us to do is trap the event and modify it.
the parameter EntityLivingHandler is the name of the class that we will create later on, it can be named whatever you like, i'm sticking with the EE3 name EnitityLivingHandler
*/
MinecraftForge.EVENT_BUS.register(new EntityLivingHandler());

//language registry stuff.

LanguageRegistry.instance().addStringLocalization("entity."+TutLib.MOD_NAME +".TutZombie.name", "TutZombie");
LanguageRegistry.instance().addStringLocalization("entity."+TutLib.MOD_NAME +".TutCreeper.name", "TutCreeper");
}

public class TutZombie extends EntityZombie {

/*
this sets it to be a villager
*/
public TutZombie(World par1World) {
     super(par1World);
     super.setVillager(true);
}
}

public class TutCreeper extends EntityCreeper {
public TutCreeper(World par1World) {
     super(par1World);
}

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); //BURN!!
         }
     }
     super.onLivingUpdate();
}
}

public class EntityLivingHandler {
/*
this function is called whenever the entity spawns in the biome and gets pushed in the event pipeline
*/

@ForgeSubscribe
public void onEntityLivingSpawn(LivingSpawnEvent event) {

/*
make sure we are on the server
*/

     if (!event.world.isRemote){
/*
is the spawn a zombie?
*/
         if (event.entityLiving instanceof EntityZombie){

/*
backup the vanilla zombie spawn for later use
*/
             EntityZombie b = (EntityZombie) event.entityLiving;

/*
check if this should have spawned in the first place
*/
             if (b.getCanSpawnHere()){

/*
create our version of the zombie in this world
*/
             TutZombie newZombie = new TutZombie(event.world);

/*
copy over the zombie coordinates and direction from the vanilla spawn over to the our spawn
*/
             newZombie.setLocationAndAngles(b.posX, b.posY, b.posZ, b.rotationYaw, b.rotationPitch);

/*
spawn our new zombie
*/
             event.world.spawnEntityInWorld(newZombie);

/*
kill off or despawn the vanilla zombie
*/
             b.setDead();
         }
         }


//again the same thing is done with the creeper
         if (event.entityLiving instanceof EntityCreeper){
             EntityCreeper b = (EntityCreeper) event.entityLiving;
             if (b.getCanSpawnHere()){
             TutCreeper newCreeper = new TutCreeper(event.world);
             newCreeper.setLocationAndAngles(b.posX, b.posY, b.posZ, b.rotationYaw, b.rotationPitch);
             event.world.spawnEntityInWorld(newCreeper);
             b.setDead();
         }
         }
     }
}

/*
this is called whenever an entity RIP
here we'll tweak the drops
*/

@ForgeSubscribe
public void onEntityLivingDeath(LivingDeathEvent event) {
/*
find out who killed this entity
*/
     if (event.source.getDamageType().equals("player")) {

/*
is the departed a monster? i.e it implementes the IMob interface? for animals they would implement the IAnimal interface
*/
         if (event.entityLiving instanceof IMob){

/*
let's narrow it down further, is the deceased a skeleton?
*/
             if (event.entityLiving instanceof EntitySkeleton){


                 double rand = Math.random();
                 //rand = 0.0d; //uncomment for instant results

                 if (rand < 0.15d) {
                     Random rnd = new Random();

/*
depending on the randomness, make them drop an emerald, diamond, fireballCharge
Note you will still get the regular skeleton loot of bone and arrow, these are extras!
*/
                     switch (rnd.nextInt(3)){
                         case 0:
                             event.entityLiving.dropItem(Item.emerald.itemID, 1);
                         break;
                         case 1:
                             event.entityLiving.dropItem(Item.diamond.itemID, 1);
                         break;
                         case 2:
                             event.entityLiving.dropItem(Item.fireballCharge.itemID, 1);
                     }
                 }
             }
         }
     }

/*
here we check if the skeleton died by being shot at with an arrow by the player
*/
     if(event.source.getSourceOfDamage() instanceof EntityArrow) {

/*
if the skeleton was shot by a dispenser this will be skipped
*/
         if(((EntityArrow) event.source.getSourceOfDamage()).shootingEntity != null) {
             if(((EntityArrow) event.source.getSourceOfDamage()).shootingEntity instanceof EntityPlayer) {
                 if(event.entityLiving instanceof IMob)
                 {
                     if(event.entityLiving instanceof EntitySkeleton){
                         double rand = Math.random();
                         //rand = 0.0d; //uncomment for instant results

                         if(rand < 0.15d) {
                             Random rnd = new Random();
                             //woot
                             switch (rnd.nextInt(3)){
                                 case 0:
                                     event.entityLiving.dropItem(Item.lightStoneDust.itemID, 1);
                                 break;
                                 case 1:
                                     event.entityLiving.dropItem(Item.redstone.itemID, 1);
                                 break;
                                 case 2:
                                     event.entityLiving.dropItem(Item.clay.itemID, 1);
                             }
                         }
                     }
                 }
             }
         }
     }
}
}

@Init
public void modInit(FMLInitializationEvent event) {
/* Steve entity */
EntityRegistry.registerGlobalEntityID(TutEntity.class, "TutEntity", EntityRegistry.findGlobalUniqueEntityId(), 7214476, 9850659);
EntityRegistry.registerModEntity(TutEntity.class, "TutEntity", 1, this, 64, 3, true);

/*
in the next 3 lines we are registering the TutEntity (Steve) with all available biomes, you can enter each biome individually seperated by a comma or use this technic with an Array list *thanks thaumcraft*
*/
ArrayList biomes = WorldChunkManager.allowedBiomes;
BiomeGenBase[] allBiomes = (BiomeGenBase[])biomes.toArray(new BiomeGenBase[]{null});

/*
Here we are registering steve to spawn naturally as a creature with weighted probability 10, and group min max of 4, this is the same as a most vanilla monster mobs. enderman is 1,1,4. the last parameter is the biomes array created above. Again you could explicitly enter the biomes sperated by comas. you could also change the type of your entity to EnumCreatureType.monster. i think that would disable it in peaceful. not sure haven't tested it.
*/

EntityRegistry.addSpawn(TutEntity.class, 10, 4, 4,EnumCreatureType.creature,(BiomeGenBase[])biomes.toArray(allBiomes));
LanguageRegistry.instance().addStringLocalization("entity."+TutLib.MOD_NAME +".TutEntity.name", "TutEntity");
}

public class TutEntity extends EntityCreature {
public TutEntity(World par1World) {
     super(par1World);
/*
set the texture of your mob like so or use the default vanilla /mob/char.png
*/
     //this.texture = "/textures/mob/char1.png";
     this.texture = "/mob/char.png";
/*
how fast they move
*/
     this.moveSpeed = 0.5F;
     //this.setSize(0.6F, 1.8F);

/*
some ai to make them do basic things like villagers, Copied from the villager entity in vanilla
*/

     this.getNavigator().setBreakDoors(true);
     this.getNavigator().setAvoidsWater(true);
     this.tasks.addTask(0, new EntityAISwimming(this));
     this.tasks.addTask(1, new EntityAIAvoidEntity(this, EntityZombie.class, 8.0F, 0.3F, 0.35F));
     this.tasks.addTask(2, new EntityAIMoveIndoors(this));
     this.tasks.addTask(3, new EntityAIRestrictOpenDoor(this));
     this.tasks.addTask(4, new EntityAIOpenDoor(this, true));
     this.tasks.addTask(5, new EntityAIMoveTwardsRestriction(this, 0.3F));
     this.tasks.addTask(6, new EntityAIWatchClosest2(this, EntityPlayer.class, 3.0F, 1.0F));
     this.tasks.addTask(6, new EntityAIWatchClosest2(this, EntityVillager.class, 5.0F, 0.02F));
     this.tasks.addTask(6, new EntityAIWander(this, 0.3F));
     this.tasks.addTask(7, new EntityAIWatchClosest(this, EntityLiving.class, 8.0F));
}

/*
set the health of your entity
*/

@Override
public int getMaxHealth() { return 20; }

/*
steve is passive but we will set the damage he can inflict
*/
public int getAttackStrength(){ return 4; }

/*
set the armor value for now it's hardcoded, but it should be depending on what they are wearing
*/
public int getTotalArmorValue() { return 4; }
}