Minecraft Forums

public class CommonProxy implements IGuiHandler
{
/** Used to store IExtendedEntityProperties data temporarily between player death and respawn or dimension change */
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
*/
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);
}
}

public class ExtendedPlayer implements IExtendedEntityProperties
{
public final static String EXT_PROP_NAME = "ExtendedPlayer";

private final EntityPlayer player;

private int currentMana, maxMana;

public ExtendedPlayer(EntityPlayer player)
{
this.player = player;
this.currentMana = this.maxMana = 50;
}

/**
* Used to register these extended properties for the player during EntityConstructing event
*/
public static final void register(EntityPlayer player)
{
player.registerExtendedProperties(ExtendedPlayer.EXT_PROP_NAME, new ExtendedPlayer(player));
}

/**
* Returns ExtendedPlayer properties for player
*/
public static final ExtendedPlayer get(EntityPlayer player)
{
return (ExtendedPlayer) player.getExtendedProperties(EXT_PROP_NAME);
}

@Override
public final void saveNBTData(NBTTagCompound compound)
{
NBTTagCompound properties = new NBTTagCompound();
properties.setInteger("CurrentMana", this.currentMana);
properties.setInteger("MaxMana", this.maxMana);
compound.setTag(EXT_PROP_NAME, properties);
}

@Override
public final void loadNBTData(NBTTagCompound compound)
{
NBTTagCompound properties = (NBTTagCompound) compound.getTag(EXT_PROP_NAME);
this.currentMana = properties.getInteger("CurrentMana");
this.maxMana = properties.getInteger("MaxMana");
System.out.println("[TUT PROPS] Mana from NBT: " + this.currentMana + "/" + this.maxMana);

}

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

/**
* Returns true if the amount of mana was consumed or false
* if the player's current mana was insufficient
*/
public final boolean consumeMana(int amount)
{
boolean sufficient = amount <= this.currentMana;
this.currentMana -= (amount < this.currentMana ? amount : this.currentMana);
this.sync();
return sufficient;
}

/**
* Simple method sets current mana to max mana
*/
public final void replenishMana()
{
this.currentMana = this.maxMana;
this.sync();
}

/**
* Returns current mana amount
*/
public final int getCurrentMana()
{
return this.currentMana;
}

/**
* Sets current mana to amount or maxMana, whichever is lesser
*/
public final void setCurrentMana(int amount)
{
this.currentMana = (amount < this.maxMana ? amount : this.maxMana);
this.sync();
}

/**
* Returns max mana amount
*/
public final int getMaxMana()
{
return this.maxMana;
}

/**
* Sets max mana to amount or 0 if amount is less than 0
*/
public final void setMaxMana(int amount)
{
this.maxMana = (amount > 0 ? amount : 0);
this.sync();
}

/**
* Makes it look nicer in the methods save/loadProxyData
*/
private static final String getSaveKey(EntityPlayer player)
{
return player.username + ":" + 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 final 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 final void loadProxyData(EntityPlayer player)
{
ExtendedPlayer playerData = ExtendedPlayer.get(player);
NBTTagCompound savedData = CommonProxy.getEntityData(getSaveKey(player));

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

public final void sync()
{
// We only ever care about getting data from the server to the client
if (FMLCommonHandler.instance().getEffectiveSide() == Side.SERVER)
{
ByteArrayOutputStream bos = new ByteArrayOutputStream(8);
DataOutputStream outputStream = new DataOutputStream(bos);

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

Packet250CustomPayload packet = new Packet250CustomPayload();
packet.channel = "tutchannel";
packet.data = bos.toByteArray();
packet.length = bos.size();

EntityPlayerMP player1 = (EntityPlayerMP) player;
PacketDispatcher.sendPacketToPlayer(packet, (Player) player1);
}
}
}

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

@ForgeSubscribe
public void onEntityJoinWorld(EntityJoinWorldEvent event)
{
if (!event.entity.worldObj.isRemote && event.entity instanceof EntityPlayer)
{
// This will sync automatically, as well as keep data persistent across player death
// if you don't care about persistent data, you should use "ExtendedPlayer.get((EntityPlayer) event.entity).sync()" instead
ExtendedPlayer.loadProxyData((EntityPlayer) event.entity);
}
}

@ForgeSubscribe
public void onLivingDeathEvent(LivingDeathEvent event)
{
if (!event.entity.worldObj.isRemote && event.entity instanceof EntityPlayer)
{
ExtendedPlayer.saveProxyData((EntityPlayer) event.entity);
}
}

@ForgeSubscribe
public void onLivingFallEvent(LivingFallEvent event)
{
if (event.entity instanceof EntityPlayer)
{
ExtendedPlayer props = ExtendedPlayer.get((EntityPlayer) event.entity);

if (event.distance > 3.0F && props.getCurrentMana() > 0)
{
System.out.println("[EVENT] Fall distance: " + event.distance);
System.out.println("[EVENT] Current mana: " + props.getCurrentMana());

float reduceby = props.getCurrentMana() < (event.distance - 3.0F) ? props.getCurrentMana() : (event.distance - 3.0F);
event.distance -= reduceby;

props.consumeMana((int) reduceby);

System.out.println("[EVENT] Adjusted fall distance: " + event.distance);
}
}
}
}

public class TutorialPacketHandler implements IPacketHandler
{
@Override
public void onPacketData(INetworkManager manager, Packet250CustomPayload packet, Player player)
{
if (packet.channel.equals("tutchannel")) {
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.setMaxMana(inputStream.readInt());
props.setCurrentMana(inputStream.readInt());
} catch (IOException e) {
e.printStackTrace();
return;
}

System.out.println("[PACKET] Mana from packet: " + props.getCurrentMana() + "/" + props.getMaxMana());
}
}

@SideOnly(Side.CLIENT)
public class GuiManaBar extends Gui
{
private Minecraft mc;

private static final ResourceLocation texturepath = new ResourceLocation("tutorial", "textures/gui/mana_bar.png");

public GuiManaBar(Minecraft mc)
{
super();
this.mc = mc;
}

@ForgeSubscribe(priority = EventPriority.NORMAL)
public void onRenderExperienceBar(RenderGameOverlayEvent event)
{
if (event.isCancelable() || event.type != ElementType.EXPERIENCE) { return; }

ExtendedPlayer props = (ExtendedPlayer) this.mc.thePlayer.getExtendedProperties(ExtendedPlayer.EXT_PROP_NAME);
if (props == null || props.getMaxMana() == 0) { return; }

int xPos = 2;
int yPos = 2;

GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
GL11.glDisable(GL11.GL_LIGHTING);
this.mc.func_110434_K().func_110577_a(texturepath);

this.drawTexturedModalRect(xPos, yPos, 0, 0, 52, 5);
int manabarwidth = (int)(((float) props.getCurrentMana() / props.getMaxMana()) * 50);
this.drawTexturedModalRect(xPos + 1, yPos + 1, 0, 5, manabarwidth, 3);
}
}