Minecraft Forums

package example;

import net.minecraft.client.Minecraft;
import net.minecraftforge.common.MinecraftForge;
import cpw.mods.fml.common.FMLCommonHandler;
import cpw.mods.fml.common.Mod;
import cpw.mods.fml.common.Mod.EventHandler;
import cpw.mods.fml.common.SidedProxy;
import cpw.mods.fml.common.event.FMLInitializationEvent;
import cpw.mods.fml.common.event.FMLPostInitializationEvent;
import cpw.mods.fml.common.event.FMLPreInitializationEvent;
import cpw.mods.fml.common.network.NetworkMod;

@Mod(modid = "TestID", name = "Test", version = "Version Test 1.0")
@NetworkMod(clientSideRequired = true, serverSideRequired = true, channels = { ExtendedPlayer.EXT_PROP_NAME }, packetHandler = TutorialPacketHandler.class)
public class Main {
private static Main instance;

@SidedProxy(clientSide = "example.ClientProxy", serverSide = "example.CommonProxy")
public static CommonProxy proxy;

public Main() {
instance = this;
}

@EventHandler
public void preInit(FMLPreInitializationEvent event) {
}

@EventHandler
public void onInit(FMLInitializationEvent event) {
MinecraftForge.EVENT_BUS.register(new TutEventHandler());
}

public static Main getInstance() {
return instance;
}
}

package example;

public class ClientProxy extends CommonProxy {
}

package example;

import java.util.HashMap;
import java.util.Map;

import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.world.World;
import cpw.mods.fml.common.network.IGuiHandler;

public class CommonProxy implements IGuiHandler {
/**
* Used to store IExtendedEntityProperties data temporarily between player
* death and respawn
*/
private static final Map<String, NBTTagCompound> extendedEntityData = new HashMap<String, NBTTagCompound>();

public void registerRenderers() {
}

@Override
public Object getServerGuiElement(int guiId, EntityPlayer player, World world, int x, int y, int z) {
return null;
}

@Override
public Object getClientGuiElement(int guiId, EntityPlayer player, World world, int x, int y, int z) {
return null;
}

/**
* Adds an entity's custom data to the map for temporary storage
*
* @param compound
* An NBT Tag Compound that stores the IExtendedEntityProperties
* data only
*/
public static void storeEntityData(String name, NBTTagCompound compound) {
extendedEntityData.put(name, compound);
}

/**
* Removes the compound from the map and returns the NBT tag stored for name
* or null if none exists
*/
public static NBTTagCompound getEntityData(String name) {
return extendedEntityData.remove(name);
}

/**
* Makes it look nicer in the methods save/loadProxyData
*/
private static String getSaveKey(EntityPlayer player) {
return player.username + ":" + ExtendedPlayer.EXT_PROP_NAME;
}

/**
* Does everything I did in onLivingDeathEvent and it's static, so you now
* only need to use the following in the above event:
* ExtendedPlayer.saveProxyData((EntityPlayer) event.entity));
*/
public static void saveProxyData(EntityPlayer player) {
ExtendedPlayer playerData = ExtendedPlayer.get(player);
NBTTagCompound savedData = new NBTTagCompound();
playerData.saveNBTData(savedData);
CommonProxy.storeEntityData(getSaveKey(player), savedData);
}

/**
* This cleans up the onEntityJoinWorld event by replacing most of the code
* with a single line: ExtendedPlayer.loadProxyData((EntityPlayer)
* event.entity));
*/
public static void loadProxyData(EntityPlayer player) {
ExtendedPlayer playerData = ExtendedPlayer.get(player);
NBTTagCompound savedData = CommonProxy.getEntityData(getSaveKey(player));

if (savedData != null) {
playerData.loadNBTData(savedData);
}

playerData.sync();
}
}

package example;

import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;

import net.minecraft.entity.Entity;
import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraft.network.packet.Packet250CustomPayload;
import net.minecraft.world.World;
import net.minecraftforge.common.IExtendedEntityProperties;
import cpw.mods.fml.common.network.PacketDispatcher;
import cpw.mods.fml.common.network.Player;

public class ExtendedPlayer implements IExtendedEntityProperties {
public final static String EXT_PROP_NAME = "Level";
private final EntityPlayer player;
private int level;
public static final int levelID = 20;

public ExtendedPlayer(EntityPlayer player) {
this.player = player;
this.player.getDataWatcher().addObject(levelID, this.level);
}

/**
* Used to register these extended properties for the player during
* EntityConstructing event This method is for convenience only; it will
* make your code look nicer
*/
public static final void register(EntityPlayer player) {
player.registerExtendedProperties(ExtendedPlayer.EXT_PROP_NAME, new ExtendedPlayer(player));
}

/**
* Returns ExtendedPlayer properties for player This method is for
* convenience only; it will make your code look nicer
*/
public static final ExtendedPlayer get(EntityPlayer player) {
return (ExtendedPlayer) player.getExtendedProperties(EXT_PROP_NAME);
}

@Override
public void saveNBTData(NBTTagCompound compound) {
NBTTagCompound properties = new NBTTagCompound();
properties.setInteger("newLevel", this.player.getDataWatcher().getWatchableObjectInt(levelID));
this.player.getDataWatcher().updateObject(levelID, properties.getInteger("newLevel"));
compound.setTag(EXT_PROP_NAME, properties);
}

@Override
public void loadNBTData(NBTTagCompound compound) {
NBTTagCompound properties = (NBTTagCompound) compound.getTag(EXT_PROP_NAME);
this.level = properties.getInteger("newLevel");
System.out.println("[NBT] Level from NBT: " + this.level);
}

@Override
public void init(Entity entity, World world) {
}

/**
* Sends a packet to the client containing information stored on the server
* for ExtendedPlayer
*/
public final void sync() {
ByteArrayOutputStream bos = new ByteArrayOutputStream(4);
DataOutputStream outputStream = new DataOutputStream(bos);

try {
outputStream.writeInt(this.level);
} catch (Exception ex) {
ex.printStackTrace();
}

Packet250CustomPayload packet = new Packet250CustomPayload(EXT_PROP_NAME, bos.toByteArray());

if (!player.worldObj.isRemote) {
EntityPlayerMP player1 = (EntityPlayerMP) player;
PacketDispatcher.sendPacketToPlayer(packet, (Player) player1);
}
}

public void setLevel(int par1) {
this.level = par1;
this.sync();
}

public final int getLevel() {
return this.player.getDataWatcher().getWatchableObjectInt(levelID);
}

public static void saveProxyData(EntityPlayer entity) {
Main.proxy.saveProxyData(entity);
}
}

package example;

import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.entity.player.EntityPlayerMP;
import net.minecraft.nbt.NBTTagCompound;
import net.minecraftforge.event.ForgeSubscribe;
import net.minecraftforge.event.entity.EntityEvent.EntityConstructing;
import net.minecraftforge.event.entity.EntityJoinWorldEvent;
import net.minecraftforge.event.entity.living.LivingDeathEvent;

public class TutEventHandler {
@ForgeSubscribe
public void onEntityConstructing(EntityConstructing event) {
if (event.entity instanceof EntityPlayer) {
ExtendedPlayer exp = ExtendedPlayer.get((EntityPlayer) event.entity);

if (exp == null) {
ExtendedPlayer.register((EntityPlayer) event.entity);
}
}
}

@ForgeSubscribe
public void onEntityJoinWorld(EntityJoinWorldEvent event) {
if (!event.entity.worldObj.isRemote && event.entity instanceof EntityPlayerMP) {
ExtendedPlayer exp = ExtendedPlayer.get((EntityPlayer) event.entity);

NBTTagCompound playerData = Main.proxy.getEntityData(((EntityPlayer) event.entity).username);

if (playerData != null) {
exp.loadNBTData(playerData);
}

exp.sync();
}
}

@ForgeSubscribe
public void onLivingDeathEvent(LivingDeathEvent event) {
if (!event.entity.worldObj.isRemote) {
if (event.entity instanceof EntityPlayerMP) {
ExtendedPlayer exp = ExtendedPlayer.get((EntityPlayer) event.entity);
NBTTagCompound playerData = new NBTTagCompound();
exp.saveNBTData(playerData);
Main.proxy.storeEntityData(((EntityPlayer) event.entity).username, playerData);
ExtendedPlayer.saveProxyData((EntityPlayer) event.entity);
}

if (event.source.getEntity() instanceof EntityPlayerMP) {
ExtendedPlayer exp = ExtendedPlayer.get((EntityPlayer) event.source.getEntity());
exp.setLevel(exp.getLevel() + 1);
exp.sync();
}

}
}
}

package example;

import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.IOException;

import net.minecraft.entity.player.EntityPlayer;
import net.minecraft.network.INetworkManager;
import net.minecraft.network.packet.Packet250CustomPayload;
import cpw.mods.fml.common.network.IPacketHandler;
import cpw.mods.fml.common.network.Player;

public class TutorialPacketHandler implements IPacketHandler {
public TutorialPacketHandler() {
}

@Override
public void onPacketData(INetworkManager manager, Packet250CustomPayload packet, Player player) {
if (packet.channel.equals(ExtendedPlayer.EXT_PROP_NAME)) {
handleExtendedProperties(packet, player);
}
}

private void handleExtendedProperties(Packet250CustomPayload packet, Player player) {
DataInputStream inputStream = new DataInputStream(new ByteArrayInputStream(packet.data));
ExtendedPlayer props = ExtendedPlayer.get((EntityPlayer) player);

try {
props.setLevel(inputStream.readInt());
} catch (IOException e) {
e.printStackTrace();
return;
}

System.out.println("[PACKET] Level from packet: " + props.getLevel());
}
}