1783
3884
[/spoiler]
[/spoiler][url=http://www.minecraftforum.net/topic/1707097-cubic-chunks-infinite-height-elimination-of-x-ray-and-more-60-supporters/page__st__0][img]http://img833.imageshack.us/img833/443/hov.png[/img][/url]
301
(don't ask, I'm not telling). You will notice that mod_bspkrsCore.cfg is no longer used; mod_bspkrsCore.bsprop.cfg is used instead. This is due to features that I've been slowly working on that are partially being released early as part of this defect release.
/igi [reload/enable/disable/toggle]
# Configuration file
####################
# general
####################
general {
# [default: true]
B:allowDebugLogging=true
# Maximum distance for the Burned Wing random teleportation. [range: 100 ~ 50000, default: 500]
I:teleDistance=500
# Number of Crystal Wing uses. Set to 0 for infinite. [range: 0 ~ 5280, default: 8]
I:uses=8
}
minecraft:apple= a single apple.
4, 128= 1 stack of cobblestone (the code that adds items to a chest truncates it to the max stack size)
351, 10, 4= 10 lapis-lazuli dyes.
1, 20 257= 20 stone blocks and 1 iron pickaxe.
# Configuration file
# Generated on 1/30/13 2:59 PM
####################
# general
####################
general {
# Limit of blocks to be destroyed at once. Use -1 for infinite. [range: -1 ~ 2147483647, default: 800]
I:blockLimit=800
# Block List, ";" splits blocks and "," splits block ID and metadata. [default: 17;]
S:blockList=17;
# Maximum number of blocks to be removed per game tick (1/20 seconds). Using a low number will keep the game from getting hugeperformance drops but also decreases the speed at which blocks are destroyed. [range: 1 ~ 1000, default: 50]
I:blocksPerTick=50
# Item drops values: 0-No drops. 1-Drops in Survival. 2-Drops in Survival & Creative. 3-Drops in Survival, Creative, & Adventure [range: 0 ~ 3, default: 1]
I:itemDropMode=1
# Maximum distance from the first block to search for blocks to destroy. Use -1 for infinite. [range: -1 ~ 1000, default: 6]
I:maxDistance=6
# Set sneakAction = "disable" to disable the block breaker effect while sneaking,
# set sneakAction = "enable" to only enable the block breaker effect while sneaking,
# set sneakAction = "none" to have the block breaker effect enabled regardless of sneaking. [default: disable]
S:sneakAction=disable
}
25
85
// Note that this step is the same in both 1.6.4 and 1.7.2.
public class TutEventHandler
{
} Step 2: Register your event handler class to EVENT_BUS either in 'load' or 'postInit' methods in your main mod. Note that this step is the same in both 1.6.4 and 1.7.2. @EventHandler
public void load(FMLInitializationEvent event)
{
// IMPORTANT: Be sure to register your handler on the correct bus!!! (see below)
// the majority of events use the MinecraftForge event bus:
MinecraftForge.EVENT_BUS.register(new TutEventHandler());
// but some are on the FML bus:
FMLCommonHandler.instance().bus().register(new YourFMLEventHandler());
} Registering to the Correct BUSFMLCommonHandler.instance().bus().register(new YourFMLEventHandler());
But it doesn't do anything right now, so on to step 3. // In your TutEventHandler class - the name of the method doesn't matter
// Only the Event type parameter is what's important (see below for explanations of some types)
@ForgeSubscribe
public void onLivingUpdateEvent(LivingUpdateEvent event)
{
// This event has an Entity variable, access it like this:
event.entity;
// do something to player every update tick:
if (event.entity instanceof EntityPlayer)
{
EntityPlayer player = (EntityPlayer) event.entity;
ItemStack heldItem = player.getHeldItem();
if (heldItem != null && heldItem.itemID == Item.arrow.itemID) {
player.capabilities.allowFlying = true;
}
else {
player.capabilities.allowFlying = player.capabilities.isCreativeMode ? true : false;
}
} If you're ever curious what variables the Event stores, type ' event. ' in Eclipse and it will bring up a menu of all the methods and variables. Or go to the implementation by ctrl-clicking on the class name. /** ArrowNockEvent should be placed in 'onItemRightClick' */
@Override
public ItemStack onItemRightClick(ItemStack itemstack, World world, EntityPlayer player)
{
// Create the event and post it
ArrowNockEvent event = new ArrowNockEvent(player, itemstack);
MinecraftForge.EVENT_BUS.post(event);
if (event.isCanceled())
{
// you could do other stuff here as well
return event.result;
}
player.setItemInUse(itemstack, this.getMaxItemUseDuration(itemstack));
}
return itemstack;
}
/** ArrowLooseEvent should be placed in 'onPlayerStoppedUsing' */
@Override
public void onPlayerStoppedUsing(ItemStack itemstack, World world, EntityPlayer player, int par4)
{
// Ticks in use is max duration minus par4, which is equal to max duration - 1 for every tick in use
int ticksInUse = this.getMaxItemUseDuration(itemstack) - par4;
ArrowLooseEvent event = new ArrowLooseEvent(player, itemstack, ticksInUse);
MinecraftForge.EVENT_BUS.post(event);
if (event.isCanceled()) { return; }
// ticksInUse might be modified by the Event in your EventHandler, so reassign it here:
ticksInUse = event.charge;
// Do whatever else you want with the itemstack like fire an arrow or cast a spell
} Step 5: Adding events to your EventHandler @ForgeSubscribe
public void methodName(EventType event)
{
// do whatever you want here
} @ForgeSubscribe
public void someEventMethod(SomeEvent event) {
System.out.println("Some event called; is this the client side? " + event.entity.worldObj.isRemote);
} // IMPORTANT: The following were for 1.6.4; while many have not changed, some most certainly have.
@ForgeSubscribe
public void onLivingHurt(LivingHurtEvent event) {}
@ForgeSubscribe
public void onPlayerHurt(LivingHurtEvent event) {} Both methods will be called each time a LivingHurtEvent is posted to the EVENT_BUS in the order they are added to the event listener (see IEventListener), which in the case above is simply their order in the code. The order can be controlled by appending (priority=VALUE) to the @ForgeSubscribe annotation, where VALUE is defined in the EventPriority enum class. HIGHEST priority is always called first, while LOWEST priority is called last. // this method will now be called after 'onPlayerHurt()'
@ForgeSubscribe(priority=LOWEST)
public void onLivingHurt(LivingHurtEvent event) {}
@ForgeSubscribe(priority=HIGHEST)
public void onPlayerHurt(LivingHurtEvent event) {} If two listeners have the same priority level, then the order is again controlled by the order in which they are added. In order to control the flow for such a case within a mod, the methods can be placed in separate 'event handler' classes to be registered in the order desired:// In the case of identical priority levels, PlayerHurtHandler will process first MinecraftForge.EVENT_BUS.register(new PlayerHurtHandler()); MinecraftForge.EVENT_BUS.register(new LivingHurtHandler());For multiple Mods that affect the same events, the order of mod registration would have the same effect.
@ForgeSubscribe // default priority, so it will be called first
public void onLivingHurt(LivingHurtEvent event) {
event.setCanceled(true);
}
@ForgeSubscribe(priority=LOWEST, receiveCanceled=true)
public void onPlayerHurt(LivingHurtEvent event) {
// un-cancel the event
event.setCanceled(false);
} By controlling the order in which each listener method is called, it is usually possible to avoid un-canceling a previously canceled event, although exceptional circumstances do arise; in those cases, extra care must be taken to avoid making logical errors. // RenderTick is client side only, so we can place the SideOnly annotation here if we want:
@SideOnly(Side.CLIENT)
public class RenderTickHandler {
// we only need one method here, and you can name it whatever you want, but
// I like to name it according to the tick to which I am listening:
@SubscribeEvent
public void onRenderTick(RenderTickEvent event) {
// now you can do whatever you want during each render tick, such as rotate the player's view
}
} If you need to do different things at the beginning of the tick than at the end of the tick, you can check the tick event's phase in your onWhateverTick method; this is applicable for all TickEvents. if (event.phase == Phase.START) {
// this is the equivalent of tickStart
}
if (event.phase == Phase.END) {
// and this is the equivalent of tickEnd
}
// if you have a lot of stuff going on in each of those, you could separate them into separate methods:
@SubscribeEvent
public void onRenderTick(RenderTickEvent event) {
if (event.phase == Phase.START) {
onTickStart();
} else {
onTickEnd();
}
} One other thing to mention here is that since we are on the client side, we might be using Minecraft.getMinecraft() quite a lot to access things like the world, player, etc. Since it would be very wasteful to have to do this each and every tick, a better way is to store the instance of Minecraft when you construct your tick handler: @SideOnly(Side.CLIENT)
public class RenderTickHandler {
/** Stores an instance of Minecraft for easy access */
private Minecraft mc;
// create a constructor that takes a Minecraft argument; now we have it whenever we need it
public RenderTickHandler(Minecraft mc) {
this.mc = mc;
}
@SubscribeEvent
public void onRenderTick(RenderTickEvent event) {
if (event.phase == Phase.START) {
// we will make the player spin constantly in circles:
mc.thePlayer.rotationYaw += 10.0F;
}
}
} public class CommonProxy {
/**
* We will call this method from our main mod class' FMLPreInitializationEvent method
*/
public void initialize() {
// since we are not registering a tick handler that ticks on the server, we will not put anything here for now
// but if you had a WorldTickEvent or PlayerTickEvent, for example, this is where you should register it
// if you try to register the RenderTickHandler here, your game WILL crash
}
}
public class ClientProxy extends CommonProxy {
// Our ClientProxy method only gets run on the client side, so it is safe to register our RenderTickHandler here
@Override
public void initialize() {
// calling super will register any 2-sided tick handlers you have that are registered in the CommonProxy
// this is important since the CommonProxy will only register it on the server side, and you will need it
// registered on the client as well; however, we do not have any at this point
super.initialize();
// here we register our RenderTickHandler - be sure to pass in the instance of Minecraft!
FMLCommonHandler.instance().bus().register(new RenderTickHandler(Minecraft.getMinecraft()));
// this is also an ideal place to register things like KeyBindings
}
}
4
record_Kitten=new MusicDisc("Kitten").setUnlocalizedName("record_Kitten").setCreativeTab(CustomTab); you should get an error under MusicDisc. we will come back to that.know you should register your item.
GameRegistry.registerItem(record_Kitten, "record_Kitten");
public class MusicDisc extends ItemRecord
{
private static final Map records = new HashMap();
public final String recordName;
public MusicDisc(String recordName)
{
super(recordName);
this.recordName = recordName;
this.maxStackSize = 1;
records.put(recordName, this);
}
@Override
public void registerIcons(IIconRegister iconRegister)
{
itemIcon = iconRegister.registerIcon("dragonborn:" + "record_" + recordName);
}
@Override
public boolean onItemUse(ItemStack itemStack, EntityPlayer player, World world, int x, int y, int z, int par7, float par8, float par9, float par10)
{
//TODO: world.getBlock()
if (world.getBlock(x, y, z) == Blocks.jukebox && world.getBlockMetadata(x, y, z) == 0)
{
if (world.isRemote)
return true;
else
{
//TODO: .insertRecord()
((BlockJukebox)Blocks.jukebox).func_149926_b(world, x, y, z, itemStack);
//TODO: Item.getIdFromItem()
world.playAuxSFXAtEntity((EntityPlayer)null, 1005, x, y, z, Item.getIdFromItem(this));
--itemStack.stackSize;
return true;
}
}
else
return false;
}
@Override
public void addInformation(ItemStack par1ItemStack, EntityPlayer par2EntityPlayer, List par3List, boolean par4)
{
par3List.add(this.getRecordNameLocal());
}
@Override
//TODO: getRecordTitle()
public String getRecordNameLocal()
{
return StatCollector.translateToLocal(this.getUnlocalizedName() + ".desc");
}
@Override
public EnumRarity getRarity(ItemStack itemStack)
{
return EnumRarity.rare;
}
public static MusicDisc getRecord(String par0Str)
{
return (MusicDisc)records.get(par0Str);
}
@Override
public ResourceLocation getRecordResource(String name)
{
return new ResourceLocation("Dragonborn:" + name);
}
}
1
9
Quote from Aeroisticon »
Yeah, it kinda is. Saying that is like saying - "If you're too poor to afford a car, than why not take it out for a 'test drive' until you have the money to pay for it? 'Test driving' it until you can work up the money for it really isn't that bad."
1
80
private static final String getSaveKey(EntityPlayer player) {
// no longer a username field, so use the command sender name instead:
return player.getCommandSenderName() + ":" + EXT_PROP_NAME;
}
public static final void loadProxyData(EntityPlayer player) {
ExtendedPlayer playerData = ExtendedPlayer.get(player);
NBTTagCompound savedData = CommonProxy.getEntityData(getSaveKey(player));
if (savedData != null) { playerData.loadNBTData(savedData); }
// we are replacing the entire sync() method with a single line; more on packets later
// data can by synced just by sending the appropriate packet, as everything is handled internally by the packet class
TutorialMain.packetPipeline.sendTo(new SyncPlayerPropsPacket(player), (EntityPlayerMP) player);
}
// remove the public void sync() method; it is no longer needed// modify this method from the wiki in the PacketPipeline class:
public void initialise() {
// NOTE: Be sure to change the channel from "TUT" to whatever you are using!!!
this.channels = NetworkRegistry.INSTANCE.newChannel("TUT", this);
// line added by me to register all my packets:
registerPackets();
}
// And add this method right below it
// IMPORTANT: Always remember to add your newly created packet classes here or you WILL crash
public void registerPackets() {
registerPacket(OpenGuiPacket.class);
registerPacket(SyncPlayerPropsPacket.class);
}public class OpenGuiPacket extends AbstractPacket
{
// this will store the id of the gui to open
private int id;
// The basic, no-argument constructor MUST be included to use the new automated handling
public OpenGuiPacket() {}
// if there are any class fields, be sure to provide a constructor that allows
// for them to be initialized, and use that constructor when sending the packet
public OpenGuiPacket(int id) {
this.id = id;
}
@Override
public void encodeInto(ChannelHandlerContext ctx, ByteBuf buffer) {
// basic Input/Output operations, very much like DataOutputStream
buffer.writeInt(id);
}
@Override
public void decodeInto(ChannelHandlerContext ctx, ByteBuf buffer) {
// basic Input/Output operations, very much like DataInputStream
id = buffer.readInt();
}
@Override
public void handleClientSide(EntityPlayer player) {
// for opening a GUI, we don't need to do anything here
}
@Override
public void handleServerSide(EntityPlayer player) {
// because we sent the gui's id with the packet, we can handle all cases with one line:
player.openGui(TutorialMain.instance, id, player.worldObj, (int) player.posX, (int) player.posY, (int) player.posZ);
}
}public class SyncPlayerPropsPacket extends AbstractPacket
{
// Previously, we've been writing each field in our properties one at a time,
// but that is really annoying, and we've already done it in the save and load
// NBT methods anyway, so here's a slick way to efficiently send all of your
// extended data, and no matter how much you add or remove, you'll never have
// to change the packet / synchronization of your data.
// this will store our ExtendedPlayer data, allowing us to easily read and write
private NBTTagCompound data;
// The basic, no-argument constructor MUST be included to use the new automated handling
public SyncPlayerPropsPacket() {}
// We need to initialize our data, so provide a suitable constructor:
public SyncPlayerPropsPacket(EntityPlayer player) {
// create a new tag compound
data = new NBTTagCompound();
// and save our player's data into it
ExtendedPlayer.get(player).saveNBTData(data);
}
@Override
public void encodeInto(ChannelHandlerContext ctx, ByteBuf buffer) {
// ByteBufUtils provides a convenient method for writing the compound
ByteBufUtils.writeTag(buffer, data);
}
@Override
public void decodeInto(ChannelHandlerContext ctx, ByteBuf buffer) {
// luckily, ByteBufUtils provides an easy way to read the NBT
data = ByteBufUtils.readTag(buffer);
}
@Override
public void handleClientSide(EntityPlayer player) {
// now we can just load the NBTTagCompound data directly; one and done, folks
ExtendedPlayer.get(player).loadNBTData(data);
}
@Override
public void handleServerSide(EntityPlayer player) {
// we never send this packet to the server, so do nothing here
}
}@NetworkMod(clientSideRequired=true, serverSideRequired=true, // packetHandler stuff)
public class ExtendedPlayer implements IExtendedEntityProperties
{
/*
Here I create a constant EXT_PROP_NAME for this class of properties. You need a unique name for every instance of IExtendedEntityProperties you make, and doing it at the top of each class as a constant makes
it very easy to organize and avoid typos. It's easiest to keep the same constant name in every class, as it will be distinguished by the class name: ExtendedPlayer.EXT_PROP_NAME vs. ExtendedEntity.EXT_PROP_NAME
Note that a single entity can have multiple extended properties, so each property should have a unique name. Try to come up with something more unique than the tutorial example.
*/
public final static String EXT_PROP_NAME = "ExtendedPlayer";
// I always include the entity to which the properties belong for easy access
// It's final because we won't be changing which player it is
private final EntityPlayer player;
// Declare other variables you want to add here
// We're adding mana to the player, so we'll need current and max mana
private int currentMana, maxMana;
/*
The default constructor takes no arguments, but I put in the Entity so I can initialize the above variable 'player'
Also, it's best to initialize any other variables you may have added, just like in any constructor.
*/
public ExtendedPlayer(EntityPlayer player)
{
this.player = player;
// Start with max mana. Every player starts with the same amount.
this.currentMana = this.maxMana = 50;
}
/**
* 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);
}
// Save any custom data that needs saving here
@Override
public void saveNBTData(NBTTagCompound compound)
{
// We need to create a new tag compound that will save everything for our Extended Properties
NBTTagCompound properties = new NBTTagCompound();
// We only have 2 variables currently; save them both to the new tag
properties.setInteger("CurrentMana", this.currentMana);
properties.setInteger("MaxMana", this.maxMana);
/*
Now add our custom tag to the player's tag with a unique name (our property's name). This will allow you to save multiple types of properties and distinguish between them. If you only have one type, it isn't as important, but it will still avoid conflicts between your tag names and vanilla tag names. For instance, if you add some "Items" tag, that will conflict with vanilla. Not good. So just use a unique tag name.
*/
compound.setTag(EXT_PROP_NAME, properties);
}
// Load whatever data you saved
@Override
public void loadNBTData(NBTTagCompound compound)
{
// Here we fetch the unique tag compound we set for this class of Extended Properties
NBTTagCompound properties = (NBTTagCompound) compound.getTag(EXT_PROP_NAME);
// Get our data from the custom tag compound
this.currentMana = properties.getInteger("CurrentMana");
this.maxMana = properties.getInteger("MaxMana");
// Just so you know it's working, add this line:
System.out.println("[TUT PROPS] Mana from NBT: " + this.currentMana + "/" + this.maxMana);
}
/*
I personally have yet to find a use for this method. If you know of any,
please let me know and I'll add it in!
*/
@Override
public void init(Entity entity, World world)
{
}
/*
That's it for the IExtendedEntityProperties methods, but we need to add a few of our own in order to interact with our new variables. For now, let's make one method to consume mana and one to replenish it.
*/
/**
* Returns true if the amount of mana was consumed or false
* if the player's current mana was insufficient
*/
public boolean consumeMana(int amount)
{
// Does the player have enough mana?
boolean sufficient = amount <= this.currentMana;
// Consume the amount anyway; if it's more than the player's current mana,
// mana will be set to 0
this.currentMana -= (amount < this.currentMana ? amount : this.currentMana);
// Return if the player had enough mana
return sufficient;
}
/**
* Simple method sets current mana to max mana
*/
public void replenishMana()
{
this.currentMana = this.maxMana;
}
}public class TutEventHandler
{
@ForgeSubscribe
public void onEntityConstructing(EntityConstructing event)
{
/*
Be sure to check if the entity being constructed is the correct type for the extended properties you're about to add! The null check may not be necessary - I only use it to make sure properties are only registered once per entity
*/
if (event.entity instanceof EntityPlayer && ExtendedPlayer.get((EntityPlayer) event.entity) == null)
// This is how extended properties are registered using our convenient method from earlier
ExtendedPlayer.register((EntityPlayer) event.entity);
// That will call the constructor as well as cause the init() method
// to be called automatically
// If you didn't make the two convenient methods from earlier, your code would be
// much uglier:
if (event.entity instanceof EntityPlayer && event.entity.getExtendedProperties(ExtendedPlayer.EXT_PROP_NAME) == null)
event.entity.registerExtendedProperties(ExtendedPlayer.EXT_PROP_NAME, new ExtendedPlayer((EntityPlayer) event.entity));
}public class ItemUseMana extends Item
{
public ItemUseMana(int id) {
super(id);
}
@Override
public ItemStack onItemRightClick(ItemStack itemstack, World world, EntityPlayer player)
{
if (!world.isRemote)
{
/*
Due to the length of code needed to get extended entity properties, I always find it handy to create a local variable named 'props' for whatever properties I need.
Also, getExtendedProperties("name") returns the type 'IExtendedEntityProperties', so you need to cast it as your extended properties type for it to work.
Old, ugly method:
ExtendedPlayer props = (ExtendedPlayer) player.getExtendedProperties(ExtendedPlayer.EXT_PROP_NAME);
This is using Seigneur_Necron's slick method (will be used from here on):
*/
ExtendedPlayer props = ExtendedPlayer.get(player);
// Here we'll use the method we made to see if the player has enough mana to do something
// We'll print something to the console for debugging, but I'm sure you'll find a much
// better action to perform.
if (props.consumeMana(15))
{
System.out.println("[MANA ITEM] Player had enough mana. Do something awesome!");
}
else
{
System.out.println("[MANA ITEM] Player ran out of mana. Sad face.");
props.replenishMana();
}
}
return itemstack;
}
}@EventHandler
public void load(FMLInitializationEvent event)
{
MinecraftForge.EVENT_BUS.register(new TutEventHandler());
}@ForgeSubscribe
public void onLivingFallEvent(LivingFallEvent event)
{
// Remember that so far we have only added ExtendedPlayer properties
// so check if it's the right kind of entity first
if (event.entity instanceof EntityPlayer)
{
ExtendedPlayer props = ExtendedPlayer.get((EntityPlayer) event.entity);
// This 'if' statement just saves a little processing time and
// makes it so we only deplete mana from a fall that would injure the player
if (event.distance > 3.0F && props.getCurrentMana() > 0)
{
// Some debugging statements so you can see what's happening
System.out.println("[EVENT] Fall distance: " + event.distance);
System.out.println("[EVENT] Current mana: " + props.getCurrentMana());
/*
We need to make a local variable to store the amount to reduce both the distance and mana, otherwise when we reduce one, we have no way to tell by how much to reduce the other
Alternatively, you could just try to consumeMana for the amount of the fall distance and, if it returns true, set the fall distance to 0, but today we're going for a cushioning effect instead.
If you want mana to be used efficiently, you would only reduce the fall distance by enough to reduce it to 3.0F (3 blocks), thus ensuring the player will take no damage while minimizing mana consumed.
Be sure you put (event.distance - 3.0F) in parentheses or you'll have a nasty bug with your mana! It has to do with the way "x < y ? a : b" parses parameters.
*/
float reduceby = props.getCurrentMana() < (event.distance - 3.0F) ? props.getCurrentMana() : (event.distance - 3.0F);
event.distance -= reduceby;
// Cast reduceby to 'int' to match our method parameter
props.consumeMana((int) reduceby);
System.out.println("[EVENT] Adjusted fall distance: " + event.distance);
}
}
}@SideOnly(Side.CLIENT)
public class GuiManaBar extends Gui
{
private Minecraft mc;
/* (my added notes:)
ResourceLocation takes 2 arguments: your mod id and the path to your texture file, starting from the folder 'textures/' from '/src/minecraft/assets/yourmodid/', or you can write it all as a single argument.
The texture file must be 256x256 (or multiples thereof)
If you want a texture to test out the tutorial with, I've uploaded the mana_bar.png to my github page:
https://github.com/coolAlias/Forge_Tutorials/tree/master/textures/gui
*/
private static final ResourceLocation texturepath = new ResourceLocation("tutorial", "textures/gui/mana_bar.png");
public GuiManaBar(Minecraft mc)
{
super();
// We need this to invoke the render engine.
this.mc = mc;
}
//
// This event is called by GuiIngameForge during each frame by
// GuiIngameForge.pre() and GuiIngameForce.post().
//
@ForgeSubscribe(priority = EventPriority.NORMAL)
public void onRenderExperienceBar(RenderGameOverlayEvent event)
{
// We draw after the ExperienceBar has drawn. The event raised by GuiIngameForge.pre()
// will return true from isCancelable. If you call event.setCanceled(true) in
// that case, the portion of rendering which this event represents will be canceled.
// We want to draw *after* the experience bar is drawn, so we make sure isCancelable() returns
// false and that the eventType represents the ExperienceBar event.
if (event.isCancelable() || event.type != ElementType.EXPERIENCE)
{
return;
}
/** Start of my tutorial */
// Get our extended player properties and assign it locally so we can easily access it
ExtendedPlayer props = ExtendedPlayer.get(this.mc.thePlayer);
// If for some reason these properties don't exist (perhaps in multiplayer?)
// or the player doesn't have mana, return. Note that I added a new method
// 'getMaxMana()' to ExtendedPlayer for this purpose
if (props == null || props.getMaxMana() == 0)
{
return;
}
// Starting position for the mana bar - 2 pixels from the top left corner.
int xPos = 2;
int yPos = 2;
// The center of the screen can be gotten like this during this event:
// int xPos = event.resolution.getScaledWidth() / 2;
// int yPos = event.resolution.getScaledHeight() / 2;
// Be sure to offset based on your texture size or your texture will not be truly centered:
// int xPos = (event.resolution.getScaledWidth() + textureWidth) / 2;
// int yPos = (event.resolution.getScaledHeight() + textureHeight) / 2;
// setting all color values to 1.0F will render the texture as it looks in your texture file
GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
// Somewhere in Minecraft vanilla code it says to do this because of a lighting bug
GL11.glDisable(GL11.GL_LIGHTING);
// Bind your texture to the render engine
this.mc.getTextureManager().bindTexture(texturepath);
/*
The parameters for drawTexturedModalRect are as follows:
drawTexturedModalRect(int x, int y, int u, int v, int width, int height);
x and y are the on-screen position at which to render.
u and v are the coordinates of the most upper-left pixel in your texture file from which to start drawing.
width and height are how many pixels to render from the start point (u, v)
*/
// First draw the background layer. In my texture file, it starts at the upper-
// left corner (x=0, y=0), ends at 50 pixels (so it's 51 pixels long) and is 4 pixels thick (y value)
this.drawTexturedModalRect(xPos, yPos, 0, 0, 51, 4);
// Then draw the foreground; it's located just below the background in my
// texture file, so it starts at x=0, y=4, is only 2 pixels thick and 49 length
// Why y=4 and not y=5? Y starts at 0, so 0,1,2,3 = 4 pixels for the background
// However, we want the length to be based on current mana, so we need a new variable:
int manabarwidth = (int)(((float) props.getCurrentMana() / props.getMaxMana()) * 49));
System.out.println("[GUI MANA] Current mana bar width: " + manabarwidth);
// Now we can draw our mana bar at yPos+1 so it centers in the background:
this.drawTexturedModalRect(xPos, yPos + 1, 0, 4, manabarwidth, 2);
}
}// Add this block of code before you draw the section of your texture containing transparency GL11.glEnable(GL11.GL_BLEND); GL11.glDisable(GL11.GL_DEPTH_TEST); GL11.glDepthMask(false); GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F); GL11.glDisable(GL11.GL_ALPHA_TEST); // Here we draw the background bar which contains a transparent section; note the new size drawTexturedModalRect(xPos, yPos, 0, 0, 56, 9); // You can keep drawing without changing anything int manabarwidth = (int)(((float) props.getCurrentMana() / props.getMaxMana()) * 49); drawTexturedModalRect(xPos + 3, yPos + 3, 0, 9, manabarwidth, 3); // NOTE: be sure to reset the openGL settings after you're done or your character model will be messed up GL11.glDisable(GL11.GL_BLEND); GL11.glEnable(GL11.GL_DEPTH_TEST); GL11.glDepthMask(true);
public void registerRenderers() {
MinecraftForge.EVENT_BUS.register(new GuiManaBar(Minecraft.getMinecraft()));
}public class TutorialPacketHandler implements IPacketHandler
{
// Don't need to do anything here.
public TutorialPacketHandler() {}
@Override
public void onPacketData(INetworkManager manager, Packet250CustomPayload packet, Player player)
{
// This is a good place to parse through channels if you have multiple channels
if (packet.channel.equals("tutchannel")) {
handleExtendedProperties(packet, player);
}
}
// Making different methods to handle each channel helps keep things tidy:
private void handleExtendedProperties(Packet250CustomPayload packet, Player player)
{
DataInputStream inputStream = new DataInputStream(new ByteArrayInputStream(packet.data));
ExtendedPlayer props = ExtendedPlayer.get((EntityPlayer) player);
// Everything we read here should match EXACTLY the order in which we wrote it
// to the output stream in our ExtendedPlayer sync() method.
try {
props.setMaxMana(inputStream.readInt());
props.setCurrentMana(inputStream.readInt());
} catch (IOException e) {
e.printStackTrace();
return;
}
// Just so you can see in the console that it's working:
System.out.println("[PACKET] Mana from packet: " + props.getCurrentMana() + "/" + props.getMaxMana());
}
}@NetworkMod(clientSideRequired=true, serverSideRequired=false, channels = {"tutchannel"}, packetHandler = TutorialPacketHandler.class)/**
* Sends a packet to the client containing information stored on the server
* for ExtendedPlayer
*/
public final void sync()
{
ByteArrayOutputStream bos = new ByteArrayOutputStream(8);
DataOutputStream outputStream = new DataOutputStream(bos);
// We'll write max mana first so when we set current mana client
// side, it doesn't get set to 0 (see methods below)
try {
outputStream.writeInt(this.maxMana);
outputStream.writeInt(this.currentMana);
} catch (Exception ex) {
ex.printStackTrace();
}
Packet250CustomPayload packet = new Packet250CustomPayload("tutchannel", bos.toByteArray());
// We only want to send from the server to the client
if (!player.worldObj.isRemote) {
EntityPlayerMP player1 = (EntityPlayerMP) player;
PacketDispatcher.sendPacketToPlayer(packet, (Player) player1);
}
}/**
* Sets current mana to amount or maxMana, whichever is lesser
*/
public void setCurrentMana(int amount)
{
this.currentMana = (amount < this.maxMana ? amount : this.maxMana);
this.sync();
}
/**
* Sets max mana to amount or 0 if amount is less than 0
*/
public void setMaxMana(int amount)
{
this.maxMana = (amount > 0 ? amount : 0);
this.sync();
}@ForgeSubscribe
public void onEntityJoinWorld(EntityJoinWorldEvent event)
{
//Only need to synchronize when the world is remote (i.e. we're on the server side)
// and only for player entities, as that's what we need for the GuiManaBar
if (!event.entity.worldObj.isRemote && event.entity instanceof EntityPlayer)
ExtendedPlayer.get((EntityPlayer) event.entity).sync();
}public static final int MANA_WATCHER = 20;
public ExtendedPlayer(EntityPlayer player)
{
this.player = player;
this.maxMana = 50;
// This adds the new object at our defined index and sets the value to max mana,
// since we should have full mana when first constructing
this.player.getDataWatcher().addObject(MANA_WATCHER, this.maxMana);
}// To save, we simply replace 'currentMana' with getWatchableObjectInt
properties.setInteger("CurrentMana", this.player.getDataWatcher().getWatchableObjectInt(MANA_WATCHER));
// To load, we need to use 'updateObject' NOT 'addObject', as the object is already added.
// If you try to add it again, you will get an error
this.player.getDataWatcher().updateObject(MANA_WATCHER, properties.getInteger("CurrentMana"));// This method gets a little messier, unfortunately, due to the unwieldy length of getting information
// from DataWatcher vs. referencing a local variable, so we'll create a local variable instead
public final boolean consumeMana(int amount)
{
// This variable makes it easier to write the rest of the method
int mana = this.player.getDataWatcher().getWatchableObjectInt(MANA_WATCHER);
// These two lines are the same as before
boolean sufficient = amount <= mana;
mana -= (amount < mana ? amount : mana);
// Update the data watcher object with the new value
this.player.getDataWatcher().updateObject(MANA_WATCHER, mana);
// note that we no longer need to call 'sync()' to update the client
return sufficient;
}
// This method cleans up nicely - no more call to 'sync()' means no custom packet to handle!
public final void replenishMana()
{
this.player.getDataWatcher().updateObject(MANA_WATCHER, this.maxMana);
}
// Simple change
public final int getCurrentMana()
{
return this.player.getDataWatcher().getWatchableObjectInt(MANA_WATCHER);
}
// Again, use 'updateObject'; we don't need to 'sync()' here anymore
public final void setCurrentMana(int amount)
{
this.player.getDataWatcher().updateObject(MANA_WATCHER, (amount < this.maxMana ? amount : this.maxMana));
}public class ExtendedLivingBase implements IExtendedEntityProperties
{
public final static String EXT_PROP_NAME = "ExtendedLivingBase";
private final EntityLivingBase entity;
private int gold;
public ExtendedLivingBase(EntityLivingBase entity)
{
this.entity = entity;
}
/**
* Used to register these extended properties for the entity during EntityConstructing event
* This method is for convenience only; it will make your code look nicer
*/
public static final void register(EntityLivingBase entity)
{
entity.registerExtendedProperties(ExtendedLiving.EXT_PROP_NAME, new ExtendedLiving(entity));
}
/**
* Returns ExtendedLiving properties for entity
* This method is for convenience only; it will make your code look nicer
*/
public static final ExtendedLiving get(EntityLivingBase entity)
{
return (ExtendedLiving) entity.getExtendedProperties(EXT_PROP_NAME);
}
@Override
public void saveNBTData(NBTTagCompound compound)
{
compound.setInteger("Gold", this.gold);
}
@Override
public void loadNBTData(NBTTagCompound compound)
{
this.gold = compound.getInteger("Gold");
System.out.println("[LIVING BASE] Gold from NBT: " + this.gold);
}
@Override
public void init(Entity entity, World world)
{
// Gives a random amount of gold between 0 and 15
this.gold = world.rand.nextInt(16);
System.out.println("[LIVING BASE] Gold: " + this.gold);
}
}@ForgeSubscribe
public void onEntityConstructing(EntityConstructing event)
{
// From last time:
if (event.entity instanceof EntityPlayer && ExtendedPlayer.get((EntityPlayer) event.entity) == null)
ExtendedPlayer.register((EntityPlayer) event.entity);
/* New stuff:
Be sure not to use 'else if' here. A player, for example, is both an EntityPlayer
AND an EntityLivingBase, so should have both extended properties
*/
if (event.entity instanceof EntityLivingBase)
/*
Just like above but we change 'ExtendedPlayer' to 'ExtendedLivingBase'
and cast event.entity to EntityLivingBase.
Isn't it nice to use the constant variable EXT_PROP_NAME in all
of our IExtendedEntityProperty classes? So easy to remember and it
stores a different name for each class. Nice.
*/
ExtendedLiving.register((EntityLivingBase) event.entity);
/* Old, cumbersome method:
event.entity.registerExtendedProperties(ExtendedLivingBase.EXT_PROP_NAME,
new ExtendedLivingBase((EntityLivingBase) event.entity));
*/
// Remember, this will also call the init() method automatically
}@ForgeSubscribe
public void onEntityJoinWorld(EntityJoinWorldEvent event)
{
if (event.entity instanceof EntityLivingBase)
{
ExtendedLiving props = ExtendedLiving.get((EntityLivingBase) event.entity);
// Gives a random amount of gold between 0 and 15
props.addGold(event.entity.worldObj.rand.nextInt(16));
System.out.println("[LIVING BASE] Gold: " + props.getGold());
}
}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);
}
}// These are methods in the EventHandler class, in case you don't know that by now
// we need to add this new event - it is called for every living entity upon death
@ForgeSubscribe
public void onLivingDeathEvent(LivingDeathEvent event)
{
// we only want to save data for players (most likely, anyway)
if (!event.entity.worldObj.isRemote && event.entity instanceof EntityPlayer)
{
// NOTE: See step 6 for a way to do this all in one line!!!
// create a new NBT Tag Compound to store the IExtendedEntityProperties data
NBTTagCompound playerData = new NBTTagCompound();
// write the data to the new compound
((ExtendedPlayer)(event.entity.getExtendedProperties(ExtendedPlayer.EXT_PROP_NAME))).saveNBTData(playerData);
// and store it in our proxy
proxy.storeEntityData(((EntityPlayer) event.entity).username, playerData);
// call our handy static one-liner to save custom data to the proxy
ExtendedPlayer.saveProxyData((EntityPlayer) event.entity);
}
}
// we already have this event, but we need to modify it some
@ForgeSubscribe
public void onEntityJoinWorld(EntityJoinWorldEvent event)
{
if (!event.entity.worldObj.isRemote && event.entity instanceof EntityPlayer)
{
// NOTE: See step 6 for a way to do this all in one line!!!
// before syncing the properties, we must first check if the player has some saved in the proxy
// recall that 'getEntityData' also removes it from the map, so be sure to store it locally
NBTTagCompound playerData = proxy.getEntityData(((EntityPlayer) event.entity).username);
// make sure the compound isn't null
if (playerData != null) {
// then load the data back into the player's IExtendedEntityProperties
((ExtendedPlayer)(event.entity.getExtendedProperties(ExtendedPlayer.EXT_PROP_NAME))).loadNBTData(playerData);
}
// finally, we sync the data between server and client (we did this earlier in 3.3)
((ExtendedPlayer)(event.entity.getExtendedProperties(ExtendedPlayer.EXT_PROP_NAME))).syncExtendedProperties();
}
}// save player data: proxy.storeEntityData(((EntityPlayer) event.entity).username + ExtendedPlayer.EXT_PROP_NAME, playerData); // save living data: proxy.storeEntityData(((EntityPlayer) event.entity).username + ExtendedLiving.EXT_PROP_NAME, playerData); // load player data: NBTTagCompound playerData = proxy.getEntityData(((EntityPlayer) event.entity).username + ExtendedPlayer.EXT_PROP_NAME); // load living data NBTTagCompound playerData = proxy.getEntityData(((EntityPlayer) event.entity).username + ExtendedLiving.EXT_PROP_NAME);
public static ExtendedPlayer get(EntityPlayer player)
{
return (ExtendedPlayer) player.getExtendedProperties(EXT_PROP_NAME);
}// Seigneur_Necron's elegance: ExtendedPlayer props = ExtendedPlayer.get(player); // vs my original super-cumbersome method: ExtendedPlayer props = (ExtendedPlayer) event.entity.getExtendedProperties(ExtendedPlayer.EXT_PROP_NAME);
/**
* Makes it look nicer in the methods save/loadProxyData
*/
private static 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 void saveProxyData(EntityPlayer player) {
ExtendedPlayer playerData = ExtendedPlayer.get(player);
NBTTagCompound savedData = new NBTTagCompound();
playerData.saveNBTData(savedData);
// Note that we made the CommonProxy method storeEntityData static,
// so now we don't need an instance of CommonProxy to use it! Great!
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);
}
// note we renamed 'syncExtendedProperties' to 'syncProperties' because yay, it's shorter
playerData.syncProperties();
}/**
* Used to register these extended properties for the player during EntityConstructing event
*/
// Note that it's static, so we can call it like this in the event:
// ExtendedPlayer.register((EntityPlayer) event.entity);
public static void register(EntityPlayer player)
{
player.registerExtendedProperties(ExtendedPlayer.EXT_PROP_NAME, new ExtendedPlayer(player));
}public class StargatePacketHandler implements IPacketHandler {
@Override
public void onPacketData(INetworkManager manager, Packet250CustomPayload packet, Player player) {
if(packet != null && packet.channel != null && packet.data != null) {
if(packet.channel.equals(StargateMod.CHANEL_TILE_ENTITY) && packet.length >= 20) {
this.handleTileEntityPacket(packet, (EntityPlayer) player);
}
else if(packet.channel.equals(StargateMod.CHANEL_COMMANDS) && packet.length >= 20) {
this.handleCommandPacket(packet, (EntityPlayer) player);
}
else if(packet.channel.equals(StargateMod.CHANEL_PLAYER_DATA) && packet.length >= 4) {
this.handlePlayerDataPacket(packet, (EntityPlayer) player);
}
}
}
protected void handlePlayerDataPacket(Packet250CustomPayload packet, EntityPlayer player) {
DataInputStream input = new DataInputStream(new ByteArrayInputStream(packet.data));
try {
int id = input.readInt();
Class<? extends PlayerDataList> clazz = getClassFromPlayerDataPacketId(id);
PlayerDataList playerData = null;
if(clazz == PlayerTeleporterData.class) {
playerData = PlayerTeleporterData.get(player);
}
else if(clazz == PlayerStargateData.class) {
playerData = PlayerStargateData.get(player);
}
if(playerData != null) {
playerData.loadProperties(input);
}
input.close();
}
catch(IOException argh) {
StargateMod.debug("Error while reading custom player data from DataInputStream.", Level.SEVERE, true);
argh.printStackTrace();
return;
}
}
// Other stuff...
}
public interface ICustomProperties extends IExtendedEntityProperties
{
public void register(EntityPlayer player);
public <T extends IExtendedEntityProperties> T get(EntityPlayer player);
public String getSaveKey(EntityPlayer player);
public void saveProxyData(EntityPlayer player);
public void loadProxyData(EntityPlayer player);
public void syncProperties();
}
1
Probably a few months, there's a lot planned, abilities, drive form levelling, limit breaks, a party system and probably more. Since it's gonna be 1.0 it's gonna be big
40
The Organization Update is officially out for Minecraft 1.10.2, 1.11.2 and 1.12
The best way to talk with us is using our Discord server here
Kingdom Keys Re:Coded is a completely rewritten version of Kingdom Keys.
This mod adds many things from the Kingdom Hearts games.
Features include:
For screenshots of all the KH1 keyblade models look here
Other screenshots can be found here
Miner_ManZ made a video in v0.6.2.1.7.10
Here's a preview video of v0.6.1
I made a video in v0.5.1.1.6.4
Whiffen/Jamie1051FTW made a spotlight in v0.4.2.1.6.2
ThnxCya made a spolight in v0.4.2.1.6.2
Darkmainiac made a spotlight in v0.3.0.1.5.2
Q. Can I add this to my server/mod pack?
A. Yes and you do not need permission.
Q. When is the next version coming out?
A. When it's ready. I will give an ETA when I feel that I can get it out by then.
Q. Will you update the mod to 1.x.x?
A. Yes as soon as Forge updates I will start working on it.
Q. When is feature x, y and z coming out?
A. In the future.
Q. Is there a wiki?
A. Right here (It's not complete, yet)
Q. My Minecraft crashed! What do I do!?
A. Post your crash report and specify which version of Kingdom Keys, Forge and Minecraft you are using. And if you are using any other mods specify which. I will likely respond to you in around a few hours to a day so be patient!
Q. Cookies!
A. Yup!
This mod was developed in Forge version 14.21.1.2426 for 1.12 So if it crashes check to see if you are using this version as newer forge updates may cause problems but most of the time they won't.
Download the mod from the Curse Forge page or the Github releases
We now have a Curse Forge page for the mod!
Report any bugs/incompatibilities through any contact method listed in the social media section.
Installation (Windows):
Source:On Github
If you make a resource pack for Kingdom Keys PM me and give me a link and I'll add it here.
Kingdom Keys Re:Coded Music pack by Wehavecookies56 (THIS PACK DOESN'T WORK IN v0.8.2+: Download
Download this resourcepack if you want custom music for the main menu and when you are in battle
Kingdom Keys Re:Coded Low-res models pack by Wehavecookies56: Download
Download this resourcepack if you have a low end PC to increase performance as well as reduce loading times
Super HD Kingdom Keys Resource pack by Abelatox and Hartsa: Download
Download this resourcepack if you want higher resolution textures for the keyblades without 3D models and some of the other items in Kingdom Keys Re:Coded.
Servers
Unfortunately none exist so far if you'd like to see an official Kingdom Keys Re:Coded server you can become a patron here to help fund it.
If you make a server using Kingdom Keys PM me.
Make sure you include the name of the server, the IP, any other requirements and the version of Kingdom Keys and forge it uses then. If I receive those details I'll add the server to here.
I am open to any ideas and if I like them I will add them to this list
If you like what we're doing then you can either pledge at out Patreon page here. Or if you prefer to do a one time donation with Paypal here.
If you'd like to join the team and you have good experience with Minecraft modding PM me.
Follow us on Twitter @KingdomKeysMod
Chat with us on Discord
PM us right here.
Of course discuss right here in the replies.
1
What the mod adds
Bonfires is a mod that brings bonfires from the Souls games to Minecraft. For those who have not played the Souls games, bonfires act like checkpoints which can be teleported to and will heal the player.
In this mod these bonfires can be created and named which then can be used to travel to any other bonfire in any dimension even mod dimensions. Using a bonfire will also set your spawn location like a bed.
It also adds the Estus Flask, which is essentially a multi use healing potion which is restored when using a bonfire.
The Coiled Sword, which is a component of bonfires, can be used as a sword which will set mobs on fire.
There are also 2 items which can be used to return to your spawn point, the Homeward Bone and the Coiled Sword Fragment.
Getting started
In 1.0.2+ you can get started with the mod without the need of looking at anything else just get killed by a mob to unlock the first advancement, which will guide you to the everything else in the mod and unlocking recipes for the recipe book.
Blocks, Items, Features and Crafting Recipes
With v1.0.2+ you can see all these recipes inside the recipe book added in Minecraft 1.12
To create a bonfire you need 2 items. A Pile of Bone and Ash and a Coiled Sword.
The Pile of Bone and Ash can be crafted like so, you can leave the top row empty and use the bottom row instead:
The items in the top are homeward bones. These are used to return to your spawn point but are consumed on use. Your spawn point is stored per dimension.
The items in the bottom are Piles of Ash which have a chance to drop from mobs when burnt to death.
Homeward Bones are crafted like so, this recipe is shapeless:
The Coiled Sword can be crafted like so:
Once you have both place the Pile of Bone and Ash on the ground and then right click it with the Coiled Sword. This will place the coiled sword on the pile creating a bonfire. Now to light the bonfire you simply right click the bonfire which will then allow you to name the bonfire. When naming the bonfire there is also the option to set the bonfire as private which will hide the bonfire from other players so they can't travel to it but can travel from it.
However, since bonfires are like teleporters they are only really useful if you make 2 of them.
If you destroy a bonfire it will drop a Coiled Sword Fragment which acts just like the Homeward Bone but is not consumed. It can also be used to create a Coiled Sword for less materials, this recipe is shapeless.
The Estus Flask when crafted has 3 uses which can be increased using Estus Shards. To reinforce the Estus Flask simply right click while holding an Estus Shard with the Estus Flask in your inventory. Drinking the Estus Flask will heal 3 hearts.
The Estus Flask is crafted like so, this recipe is shapeless:
And Estus Shards are crafted like so, this recipe is shapeless:
Lastly Ash Blocks can be crafted which act exactly like sand, this recipe is actually also shapeless but there's no way to tell that!
And of course a block will create 9 Piles of Ash, this recipe is shapeless
Commands
There are currently 2 commands added by Bonfires both of which are admin commands
/bonfires [parameter]
This command is used to display the bonfires in the world based on the filters given to it.
Bonfires are displayed in the chat with the name, UUID, owner and position
The filters include:
/travel
This command will teleport the user of the command to the bonfire with the given UUID
The UUID of a bonfire can be found either using the /bonfires command or by hovering over the name of the bonfire in the travel menu in the bonfire GUI
Configuration
If you have any ideas for more config options please suggest more that could be added.
The config file is simply named bonfires.cfg
Render Text Above Bonfires (Default: true)
This config option is quite self explanatory, simply if set to true it will display the name of the bonfire above the block when looked at otherwise if set to false it will not. In v1.0.2+ this option can be changed within Forge's config GUI without restarting the game.
Bonfire Dimension Tab Icons
This config option is used to set the icon for the tab for associated dimension ID.
By default it is set to:
S:"Bonfire dimension tab icons" < 0=minecraft:grass -1=minecraft:netherrack 1=minecraft:end_stone >It takes the dimension ID then the item name so for example:
S:"Bonfire dimension tab icons" < 0=minecraft:grass -1=minecraft:netherrack 1=minecraft:end_stone 2=bonfires:coiled_sword >This will set the icon for the dimension with ID 2 to have the Coiled Sword from this mod as the icon for the tab, if the icon is not set or the item given doesn't exist the icon will be a map.
Pictures
Download
The newest version is v1.1.0 for Minecraft 1.12 and requires Minecraft Forge (1.12-14.21.1.2420 is recommended).
The newest version is v1.0.1 for Minecraft 1.11 and requires Minecraft Forge (1.11-13.19.1.2195 is recommended).
The newest version is v1.0.1 for Minecraft 1.10.2 and requires Minecraft Forge (1.10.2-12.18.3.2185 is recommended).
It can be found on curse forge here:
Known issues
All the known issues are located here, if you do come accross one please report it here
Please make sure before reporting an issue that you are using the latest version and that it has not already been reported.
Can I use this in a modpack?
Of course! I would prefer if you credited me however, it is not required.
Planned Features
Big thanks to
1
It is indeed, we should probably use the twitter account more often. Our discord server is where we mostly discuss things https://discord.gg/0zi76zYpsj7DM9zp
1
Kizunacraft v1.2 has been released for Minecraft 1.10
Here's what's changed:
1
Kingdom Keys Re:Coded 0.7.6 has been released!
It's finally here everyone there's a bunch of new features so go look at the changelog
The Drive Forms now render on the player so Render Player API is required again please install it or the game will crash!
You can download it below:
Downloads | Mirror
If you'd like to support us use these links
Link Removed | Link Removed
One of the new features in 0.7.6 is custom music for the main menu and for battle. The music is not packaged with the mod due to the filesize being way to large so if you want to use the custom music download the resourcepack here. You can also download the low-res 3D model textures resourcepack there if you want faster loading times or increased performance.
As usual if you encounter any bugs, crashes, problems, etc. notify me so we can get it fixed.
And finally have fun
1
I have some ideas for 1.9, waiting on forge to update first of course.
The update should be out tomorrow if everything goes smoothly.
1
Kingdom Keys Re:Coded 0.7.5.1 for Minecraft 1.8 has been released!
Just a small update that fixes the KH1 model textures.
Can be downloaded in the usual spot.
EDIT:
Kingdom Keys Re:Coded 0.7.5.2 for Minecraft 1.8 has been released!
Yet another update, fixes levels on multiplayer. Changed the recipes for knowledge and made manifest knowledge work without looking at a block.
Can be downloaded in the usual spot.
2
Hey everyone, I thought I would just announce that Kingdom Keys is being recoded (Abel did mention this) and will be titled Kingdom Keys Re:Coded.
This is because of the changes in 1.8 making it kinda hard to port it directly so that's why. It does mean we are doing some things more efficiently and should have less bugs.
Don't worry it may sound like this will take a very long time but we are actually being pretty quick.
You can follow the development here.
I should also mention the 3D models won't be in the new version initially because of it being pretty hard to convert Techne models to the new format.
So stay tuned for more
1
I wouldn't say that, small patches are necessary to make the experience of using the mod more enjoyable. Waiting a long time for a new major update to come out with bug fixes that are quick to fix isn't great.