[1.7.10] Custom Furnace Different Speed Per Item?

[HalestormXV]

Alright I have a question. I have a custom furnace that is working great, along with a custom smelting handler where I can input my own items. The furnace works fine. It triple standard ore recipes and because I have a custom SmeltingHandler, all of my custom recipe do not triple.

 

I want to take this a step further if at all feasible. I want to adjust the furnace's speed and active texture if one of my custom smelting recipes are in there. So say I am smelting an item that is actually in my custom smelting handler, the furnace will smelt the item slower and the texture on the front of the block will look different.

 

If it makes it easier, I wouldn't mind if you still have burn time remaining in the furnace and by inputting one of my custom recipes the burn time resets to 0 thus needing new fuel (which makes sense since it is in another "mode")

 

http://pastebin.com/uHYRcccc - FurnaceTile Entity

http://pastebin.com/NTQSTrfh - Furnace Block

 

I will admit I have no idea which direction to go in to accomplish this. So any help is appreciated. It doesn't "sound" overly complex, but then again there is a huge difference to explanation and making it happen.

[coolAlias]

In the methods that check the current smelting recipe, you can alter the furnace's smelting time requirement based on the recipe, e.g. in #getCelestialSmelt, before returning 'true' set the furnace speed to 120 or however long you want it to take.

 

Be sure to set it back for regular recipes.

 

As for having a different texture, in the same methods as above, you could change the block's metadata (bit 4 should be available, unless you used that for active vs. inactive) and then return the face texture based on that flag.

[HalestormXV]

Alright I got the different times set up and working by adding this to the tileEntity code:

 

public boolean canSmelt(){
	if(this.slots[0] == null){
		return false;
	}else{
		ItemStack itemstack = FurnaceRecipes.smelting().getSmeltingResult(this.slots[0]);
		if(itemstack == null) return false;
		if(this.slots[2] == null) { this.furnaceSpeed = 45; return true;}
		if(!this.slots[2].isItemEqual(itemstack)) return false;

		int result = this.slots[2].stackSize + itemstack.stackSize;
		return ( result <= getInventoryStackLimit() && result <= itemstack.getMaxStackSize() );
	}
}

public boolean canCelestialSmelt(){
	if(this.slots[0] == null){
		return false;
	}else{
		ItemStack itemstack = CelestialFurnaceRecipes.smelting().getSmeltingResult(this.slots[0]);
		if(itemstack == null) return false;
		if(this.slots[2] == null){ this.furnaceSpeed = 200; return true;}
		if(!this.slots[2].isItemEqual(itemstack)) return false;

		int result = this.slots[2].stackSize + itemstack.stackSize;
		return ( result <= getInventoryStackLimit() && result <= itemstack.getMaxStackSize() );
	}
}

 

Works fine so far. Only problem is that the cookBar that is shows to the client is not representing the change in time accurately but that is probably something I can easily fix with some minor tweaks where that shows up.

 

But I can't seem to figure out what you mean by changing the meta while it is doing a celestialSmelt.

 

I imagine in the block class under my getIcon function I could case/switch the second argument which is the meta-value or check it otherwise like you said above. But how would I go about changing that in the tileEntityClass once it is active.

 

Its not as simple as calling a this.blockMetadata = 4; in the celestialSmelt function is it?

[coolAlias]

Almost that simple, yes - you just need to call the setBlockMetadataWithNotify method using your TE's worldObj. Make sure to set it back when there is not a valid celestial recipe being smelted.

[HalestormXV]

Alright after some tweaking and your help I got it. The alternate textures work now. However, arises 2 new issues and I am for sure that this is from an oversight on my part without a doubt. The issue is now the block doesn't auto-rotate when you place it so the front is always "facing you." And the progress bar goes all out of whack when you switch from smelting a celestial item or a regular item. When smelting a regular item it fills the progress bar fine. But when smelting a celestial item which has a speed of 200 the progress bar doesn't represent it properly.

 

Now I know for sure this is likely because I am manipulating its meta-data on the fly and those timers and variables are stored with the original meta-data. Perhaps I just need another pair of eyes to look at this and tell me where I need to make the changes. Once again I am fairly certain it has to do with me manipulating the meta-data like that but I just can't find where that manipulation caused those errors since I have been working on this furnace for like 2 days now lol.

 

Here is the new code:

http://pastebin.com/eXpNh9i2  - TileEntity

http://pastebin.com/9XxFyKGL - BlockClass

 

[coolAlias]

Timers shouldn't be affected by meta-data, but you need to store the rotation data as well, which is why I suggested using bit number 4 (i.e. value=.

 

Are you familiar with bitwise operators? e.g.

int meta = 3; // some facing information, original texture
meta |= 8; // add flag for your custom texture, keeping all original data; meta is now 11
meta = meta & 7; // removes everything but the first 3 bits (values 0-7), meta is now back to 3, the original rotation

You need to do something like that when you set the metadata.

[HalestormXV]

Well hell, i can say i am not at all familiar with that. Could you provide an example of it in action with the code? I do see your examples also but cant figure how i would apply that. I mean i get the concept.

[coolAlias]

If you're not familiar with bitwise operations or what things like AND, OR, XOR, etc. mean, then I suggest you look them up. It helps even more if you understand binary, as bitwise operations work on individual bits:

 

0 0 1 1  (4 bits, value = 3)

 

1 0 1 1  (toggled bit # 4 to on [ reading from right to left ], value now = 11)

 

0 0 1 1  (toggled bit # 4 again to off, value now = 3 again)

 

The example above is pretty close to what you would write in actual code, except you would get the first metadata value from the World instance, e.g. world.getBlockMetadata(x, y, z) or whatever it is.

 

Then, based on the state of your TE, you either add or subtract 8 (which is effectively what those 2 bitwise operations do) and set that as the new metadata. That's it.

[HalestormXV]

Alright I am really trying here as this is the last step for this furnace. And after reading your post and your link I am grasping it. I imagine i am doing this in the onBlockPlaced correct? Since everything else is working with the exception of when I place the block?

 

BlockPlace:

 

 

	public void onBlockPlacedBy(World world, int x, int y, int z, EntityLivingBase entity, ItemStack itemstack){
	int direction = MathHelper.floor_double((double)(entity.rotationYaw * 4.0F / 360.0F) + 0.5D) & 3;

	if (direction == 0){
		world.setBlockMetadataWithNotify(x, y, z, 2, 2);
	}
	if (direction == 1){
		world.setBlockMetadataWithNotify(x, y, z, 5, 2);
	}
	if (direction == 2){
		world.setBlockMetadataWithNotify(x, y, z, 3, 2);
	}
	if (direction == 3){
		world.setBlockMetadataWithNotify(x, y, z, 4, 2);
	}

	if(itemstack.hasDisplayName()){
		((TileEntityCelestialFurnace) world.getTileEntity(x, y, z)).setGuiDisplayName(itemstack.getDisplayName());
	}
}

 

 

It is in here that I would have to collect and store the blockMetaData?

int meta = direction;

 

Or do I collect the meta in the method right below that which is the updateBlockState like so:

	int direction = world.getBlockMetadata(x, y, z);
	TileEntity tileentity = world.getTileEntity(x,  y,  z);	
	int meta = tileentity.getBlockMetadata();

 

UpdateBlockStateCode

 

public static void updateCelestialFurnaceBlockState(boolean burning, World world, int x, int y, int z){
	int direction = world.getBlockMetadata(x, y, z);
	TileEntity tileentity = world.getTileEntity(x,  y,  z);

	int meta = tileentity.getBlockMetadata();

	keepInventory = true;

	if(burning){
		world.setBlock(x, y, z, CelestialCraft_blocks.celestialFurnaceActive);
	}else{
		world.setBlock(x, y, z, CelestialCraft_blocks.celestialFurnace);
	}

	keepInventory = false;
	world.setBlockMetadataWithNotify(x, y, z, direction, 2);
	//world.setBlockMetadataWithNotify(x, y, z, meta, 2);

	if(tileentity != null){
		tileentity.validate();
		world.setTileEntity(x, y, z, tileentity);
	}
}

 

 

 

 

And then with meta now stored in this update method I run an if check which will say

if meta = 4 (Celestial Smelting) meta |= 8;

else if meta = 2 (Standard Smelting) meta = meta & 7;

 

then at the very bottom before the method closes off

world.setBlockMetadataWithNotify(x, y, z, meta, 2);

 

 

[coolAlias]

Please read the wiki on furnace metadata states. You can't use 2 or 4 - they are taken. The value 8, however, at bit location 4, is free, so you can use that as a flag similar to how buttons have an 'on/off' toggle. That's exactly what you are doing here.

 

And yes, it goes in the update section, not when you place the block. When the block is placed, nothing is in it, so you don't care about setting the last bit, just leave it at the default 'unset' state.

[HalestormXV]

The value 8 is good to use because bit value 4 is free correct. So in the TileEntity where I am setting the metadata marked with 2 asterisks is okay.

 

 

[code= public boolean canCelestialSmelt(){
if(this.slots[0] == null){
return false;
}else{
ItemStack itemstack = CelestialFurnaceRecipes.smelting().getSmeltingResult(this.slots[0]);
if(itemstack == null) return false;
if(this.slots[2] == null){
this.furnaceSpeed = 200;
**this.worldObj.setBlockMetadataWithNotify(xCoord, yCoord, zCoord, 8, 2); return true;}
if(!this.slots[2].isItemEqual(itemstack)) return false;

int result = this.slots[2].stackSize + itemstack.stackSize;
return ( result <= getInventoryStackLimit() && result <= itemstack.getMaxStackSize() );
}
}[/code]

 

 

 

Now I know that works because my front textures alternate as they should if I am smelting a Celestial Item, and then it reverts back to normal if I start smelting a normal item. So I know my meta data is being checked and stored correctly. What I am struggling to understand and perhaps what is making me so confused with this is why my furnace will not maintain it's direction if I use one function, yet if I use the other function it does keep its direction just doesn't switch the texture.

 

Here is the current getIcon function

 

 

    public IIcon getIcon(int side, int meta)
    {
            if(side == 1){
                    return this.top; // Side 0 = Bottom
            }else if (side == 2 && meta != 8 ){
                    return this.front;
            }else if (side == 2 && meta == {
                    return this.frontAlt;
            }else{
                    return this.blockIcon; // Side 5 = East/Right
            }
    }

 

 

This is the one that works and switches the texture correctly back and forth yet doesn't rotate my furnace and automatically makes the face point north.

 

HOWEVER, this function which was my original, before I decided to do the CelestialMode smelting does work:

 

 

@SideOnly(Side.CLIENT)
public IIcon getIcon(int side, int meta)
{
	return side == 1 ? this.top : (side == 0 ? this.top : (side != meta ? this.blockIcon : this.front));
}

 

 

That function makes the furnace's front texture face me no matter where I placed it and the furnace maintains its direction when I start smelting. Now granted I know my this.frontAlt is not referenced anywhere in that method but isn't there a way I can check the metavalue in that method and if it finds an 8 it will use the this.frontalt?

 

I guess where I am struggling with this bit operation is why in one function it works as it should (not the bitOperation but the rotation), but in the other it doesn't. Then what is even more frustrating is I am grasping what you are explaining and it makes sense but I can't seem to understand how to actually store the location info and then add a new flag to it.

 

Like it seems stupidly obvious:

 

int direction world.getBlockMetadata(x, y, z);  Get our current block meta-data that has already been placed down. Everything is stored in there.

TileEntity tileentity = world.getTileEntity(x,  y,  z); gets the TileEntity

int tileentity.getBlockMetadata(); gets the metadata from our TileEntity class which we set to 8 in its celestialSmelt function

 

For some unknown reason I get blocked here. Yet in reading your posts I know this is probably where I shouldn't get blocked because after I have gathered that information it is just a matter of saying hey if 8 is part of the metaData we use a different texture. But if 8 isn't in that metaData we use the regular texture. And I know that the furnace is 3 bits. So 8 + 3 = 11 so therefore we are checking to see if 11 is the meta-data and if it is we use the alternate front texture and if it isn't we use the default front texture. But I just can't figure out how to put that into the code.

 

 

[coolAlias]

Keep the original function, but put this:

boolean useCelestialTexture = (meta &  > 0; // true if bit 4 is set
meta = (meta & 7); // remove bit 4 because it is throwing off all of your meta values
// rest of getIcon function contents here, EXCEPT:
... blockIcon : this.front));
// change to:
... blockIcon : (useCelestialTexture ? this.celestial : this.front)));

Or whatever the texture name is.

[HalestormXV]

Excellent! It is partially working. My textures are altering correctly now WITH the placement of my blocks. So the block when placed will always face me with the inActive front.

 

Only one problem remains and once solved I will proceed to never do this again or work with bitValues until I am absolutely comfortable with them.

 

The only problem that remains is this. Once the furnace is in "CelestialMode" which uses the alternate texture it rotates the front texture to face the south side. So it switches the texture correctly but the block doesn't stay facing its original direction. Then if you switch the recipe to a normal smelting recipe the alternate texture remains in effect and the block stays facing the south with the alternate texture.

 

The good thing is that in doing this "way out of my league" type of code I am learning and know that this is occurring due to me doing something wrong in my: public static void updateCelestialFurnaceBlockState in this blockClass.

 

 

public static void updateCelestialFurnaceBlockState(boolean burning, World world, int x, int y, int z){
	int direction = world.getBlockMetadata(x, y, z);
	TileEntity tileentity = world.getTileEntity(x,  y,  z);
	int meta = tileentity.getBlockMetadata();


	keepInventory = true;

	if(burning){
		world.setBlock(x, y, z, CelestialCraft_blocks.celestialFurnaceActive);
	}else{
		world.setBlock(x, y, z, CelestialCraft_blocks.celestialFurnace);
	}

	keepInventory = false;

	if (meta == 11)
	{
		direction |= 8;
		meta = meta & 7;
		world.setBlockMetadataWithNotify(x, y, z, direction, 2);
	}else{
		direction = meta;
		world.setBlockMetadataWithNotify(x, y, z, direction, 2);
	}




	if(tileentity != null){
		tileentity.validate();
		world.setTileEntity(x, y, z, tileentity);
	}
}

 

 

And yeah I know I should have never ventured this far without a better base understanding of this meta manipulation and I happily admit that. But this is for sure a lesson learned. This I believe is it. Once I rectify this error I think this block is done and done.

[coolAlias]

It takes some time / practice to understand, but learning about how bits work is really fundamental to a lot of programming concepts (e.g. compression).

 

Anyway, your meta value logic is all messed up

// These 2 values should be identical, for one
int direction = world.getBlockMetadata(x, y, z);
int meta = tileentity.getBlockMetadata();

// Why only metadata == 11? Do you realize what that means?
// Furnace meta values = 2, 3, 4, or 5
// Your bit toggle = furnace meta +0 (default texture) or +8 (celestial texture), so:
// 2, 3, 4, 5 = default texture facing one of four directions
// 10, 11, 12, 13 = celestial texture facing one of four directions
if (meta == 11) { // so this is only celestial texture facing direction 3...
    direction |= 8; // and this does nothing, because bit 4 (value =  is already set, so direction still = 11
    meta = meta & 7; // what's this doing here? you don't even use this variable anywhere
    world.setBlockMetadataWithNotify(x, y, z, direction, 2); // so now you set the metadata to the same value it was, 11
} else {
   direction = meta; // probably already equal, as noted above
   world.setBlockMetadataWithNotify(x, y, z, direction, 2); // so this does nothing
}

Is that the only place you change the metadata? Because it doesn't look to me like you are changing anything...

[HalestormXV]

EDIT: SNIP

 

 

Holy hell, coolAlias, thank you so much! I had a massive post here before basically raging at how dumb I felt, that I couldn't figure this out lol and I know I am not an idiot and that is what was frustrating me more.

 

But I calmed down a bit, carefully re-read your comments and explanations. Watched a bitOperator tutorial on YouTube and re-focused myself with a a cup of Cinabun coffee and FIXED THE BLASTED THING.

 

I was setting my MetaData wrong in the TileEntity class. I was setting 1 value of the meta-data which was only corresponding to south side as opposed to setting all values of the meta data as your comment indicated 10, 11, 12, 13.

 

So the fix, now that I see how stupidly simple was, is exactly as you stated "like a switch." I just couldn't figure out how to create "the switch." But once I tried it and it worked I had a big sign of relief and satisfaction followed quicky with a  "I want to smash my head into the desk, because I didn't notice it."

 

Here is the new TileEntity methods that I had to adjust.

 

	public boolean canSmelt(){
	if(this.slots[0] == null){
		return false;
	}else{
		ItemStack itemstack = FurnaceRecipes.smelting().getSmeltingResult(this.slots[0]);
		if(itemstack == null) return false;
		if(this.slots[2] == null) { this.furnaceSpeed = 45; 
		int meta = this.getBlockMetadata();
		this.worldObj.setBlockMetadataWithNotify(xCoord, yCoord, zCoord, meta = meta & 7, 2);
		return true;}
		if(!this.slots[2].isItemEqual(itemstack)) return false;
		int result = this.slots[2].stackSize + itemstack.stackSize;
		return ( result <= getInventoryStackLimit() && result <= itemstack.getMaxStackSize() );
	}
}

public boolean canCelestialSmelt(){
	if(this.slots[0] == null){
		return false;
	}else{
		ItemStack itemstack = CelestialFurnaceRecipes.smelting().getSmeltingResult(this.slots[0]);
		if(itemstack == null) return false;
		if(this.slots[2] == null){ 
			this.furnaceSpeed = 200; 
			int meta = this.getBlockMetadata();
			this.worldObj.setBlockMetadataWithNotify(xCoord, yCoord, zCoord, meta|=8, 2); return true;}
		if(!this.slots[2].isItemEqual(itemstack)) return false;

		int result = this.slots[2].stackSize + itemstack.stackSize;
		return ( result <= getInventoryStackLimit() && result <= itemstack.getMaxStackSize() );
	}
}

 

 

Here is the adjusted update method in the BlockClass:

 

	public static void updateCelestialFurnaceBlockState(boolean burning, World world, int x, int y, int z){
	int direction = world.getBlockMetadata(x, y, z); **No longer needed
	TileEntity tileentity = world.getTileEntity(x,  y,  z);
	int meta = tileentity.getBlockMetadata();


	keepInventory = true;

	if(burning){
		world.setBlock(x, y, z, CelestialCraft_blocks.celestialFurnaceActive);
	}else{
		world.setBlock(x, y, z, CelestialCraft_blocks.celestialFurnace);
	}

	keepInventory = false;

	world.setBlockMetadataWithNotify(x, y, z, meta, 2);





	if(tileentity != null){
		tileentity.validate();
		world.setTileEntity(x, y, z, tileentity);
	}
}

 

 

 

 

So now just to make sure I grasp your lessons, because you have helped me out tremendously and I just don't want answers. I want to learn. So I want to make sure I learned this correctly.

 

The furnace used 3 bit values. 1 2 and 4 are all taken and store the side/rotation data. front face, side face, etc. etc. Bit value 8 is free. So we can store new data in there. So what this code did in the TielEnttiy class is first store whatever the current meta data of the block is. Then it added the bit value 8 to it which takes the meta-data range of 10, 11, 12, 13. So essentially in doing that the code now says:

 

Okay the new metaData of this block which is retrieved in the updateMethod via "int meta = tileentity.getBlockMetadata();" of the block class is whatever the original meta-data which is defined in the TileEntity class edit I made via "int meta = this.getBlockMetadata();" was and now add fields 10, 11, 12, and 13 OR more simply bitValue 8 via the other tileEntity edit I made: "this.worldObj.setBlockMetadataWithNotify(xCoord, yCoord, zCoord, meta|=8, 2)".

 

That is what the iconCheck is looking at correct? It is saying hey we have some new fields on this. Boolean check if they are |8 and if so take all the direction data except whatever corresponds to side front and switch up its texture. (I:E: now 10, 11, 12, 13).

 

Then the second part of this code is what occurs if you are not doing a celestialSmelt. Essentially it does the exact same thing as above except now it uses & 7 which as you said basically strips away all of those added values from |8 and says just keep the original and then the check says okay not new meta fields in |8 strip them out and use the default data.

 

And because this data is stored on the block itself in the block's meta and the block and TileEntity is its own instance of each other so therefore each block acts independently of one another on a ServerWorld or a SinglePlayer world.

 

Sorry for that long winded explanation but I wanted to make sure I understand this now and also let you know that I actually learned this thanks to you so your efforts were not in vain lol.

[coolAlias]

There ya go! Nice work 

[HalestormXV]

Thank you sir and my last final question is more one just of general inquiry. Naturally since I am changing the furnaceSpeed based on the mode you are in I want the progress bar to represent that. Not always moving at the same speed and then overflowing off the GUI because it doesn't realize the speed has actually changed.

 

So I simply just changed the furnaceSpeed to be a static variable indicating that "Hey this can change" and other classes will look at it so be aware of it. This fixed the issue and the progress bar now correctly represents the change in speed. If we are in CelestialMode it move nice and slow, and if we are in normalMode it goes faster and does not overflow off the GUI.

 

My inquiry is that doing that is the correct (if not only) way to go about it right and won't have any consequences?

[coolAlias]

That is not the correct way - static means only ONE instance of that variable exists for all instances of the class, so if one TileEntity changes the speed, EVERY TileEntity changes its speed.

 

The correct way is to keep it as a regular class member or, and possibly better, change it to a function, e.g.:

public int getCurrentFurnaceSpeed() {
if ((blockMetadata &  == 0) {
   return celestialSpeed;
} else {
   return regularSpeed;
}
}

Then you can call that from your Container / Gui classes when determining the progress bar status. The nice thing about using a method like the above is  that the client also knows the current block metadata, so you don't need to worry about synchronizing your class field for the speed.

[HalestormXV]

Alright, the function was my original guess. I just wasn't sure if static would work because I was using this or not and the fact it worked right away biased my thoughts. But your right function is the better route to go. Okay, no problem then.