EnumFacing is a 6-value property.

If you don't want to have a block face up/down you can use EnumFacing.getHorizontalIndex instead.

22 minutes ago, Draco18s said:

EnumFacing is a 6-value property.

If you don't want to have a block face up/down you can use EnumFacing.getHorizontalIndex instead.

 

Similar to what you did here: 

 

but wouldn't that mean I'd have to change all the code around for the block along with the JSON properties for it? Or  are you saying I have to do that anyway, because I cannot get the data for blockIsActive effectively because it is only going to be a 0 or a 1 and it won't be able to be stored correctly to begin with? I mean if EnumFacing is 6-value and this boolean is 1 Value (true or false) that is a total of 7. Can't the block store 16 bits? So why would have to change it, unless the boolean isn't able to be stored corretly.

 

Edited September 2, 20178 yr by HalestormXV

15 minutes ago, HalestormXV said:

but wouldn't that mean I'd have to change all the code around for the block along with the JSON properties for it? Or  are you saying I have to do that anyway, because I cannot get the data for blockIsActive effectively because it is only going to be a 0 or a 1 and it won't be able to be stored correctly to begin with? I mean if EnumFacing is 6-value and this boolean is 1 Value (true or false) that is a total of 7. Can't the block store 16 bits? So why would have to change it, unless the boolean isn't able to be stored corretly.

 

That's not 7, that's 12.

2 possibilities * 6 possibilities = 12

You can also use a different bit (6 -> 8, uses bx0111, leaves bx1000 for the boolean)

Thanks. I think I got it. I shifted it one more spot over:

@Override
public int getMetaFromState(IBlockState state)
{
    int blockIsActive = (state.getValue(BURNING) ? 1 : 0) << 3;
    int facingDirection = ((EnumFacing)state.getValue(FACING)).getIndex();
    return facingDirection | blockIsActive;
}

 

And switched up the facing (to use horizontal) along with the ordering:

@Override
public IBlockState getStateFromMeta(int meta)
{
    EnumFacing facing = EnumFacing.getHorizontal(meta);
    if(facing.getAxis() == EnumFacing.Axis.Y)
        facing = EnumFacing.NORTH;

    boolean blockIsActive = (meta & 8) > 2;

    return this.getDefaultState().withProperty(FACING, facing).withProperty(BURNING, blockIsActive);
}

I imagine all of this is correct? Since it seems to be replicating properly in game. And that ( meta & 8 ) > 2 effectively takes whatever the 8th value of the meta is compares if it is greater than 2 and destroys the rest? 

 

I do apprecaite all the help you gave me through all of this. Now my last request. And this has nothing to do with the code. This purely has to do with me wanting to learn so I know how to manipulate the metadata/bits in the future. I started off with the original example shifting the bits over with this ? 1 : 0 << 2 which basically added 2 zeros to the 1 or the 0 right? Effectively multiplying the number by 2. So either 2 * 1 or 2* 0. Which shifted the bits over 2 places. But that wasn't good enough because I was using the Enum Facing which takes 6 spots. So when I was trying to pull the data out it was screwing crap up. So by changing the EnumFacing facing = EnumFacing.getFront(meta); to EnumFacing facing = EnumFacing.getHorizontal(meta) it freed up two extra spots or 1 Extra Spot? in the bit data. 

 

So once I changed that and then changed the shift over to a 3 with << 3 it moved the boolean value (1 or 2) over 6 bytes (3*2) or did it just add 3 zeros to the value? Regardless of what it did, the actual code effectively moved the boolean value (1 or 2) over enough spaces so that there was no conflict with the facing data and was able to extract the new reduced facing data (4 values instead of 6) and the boolean value (0 or 1). 

 

Does that sound right or is it somewhat right. Like I said, I don't just want answers I legeitametly want to learn by code what is going on. And tutorials, classes, etc. can only do so much (for me at least). For me i learn best by seeing an example and trying/doing a replication of it and then I can see its functionality. Everyone is different but that is just how I learn. And if at all possible in your explanation can you not use bx0111 etc. that quite literally confused the crap out of me. (I think it means decimal value of a number?)

Edited September 2, 20178 yr by HalestormXV

This is an excellent reference point. Can you explain exactly how the meta & 3 works? Is it similar to my post above?

https://en.wikipedia.org/wiki/Bitwise_operation#AND

1 hour ago, Draco18s said:

https://en.wikipedia.org/wiki/Bitwise_operation#AND

I am aware of the wikipedia link and how the operators function. Thats why I used them in the code. What I am asking is how it works in his code in a simplified explanation for people like myself and others who may view this post and seek a more defining answer specifically to what is going on in this code. Different explanations or explaining something different ways help me learn as I am sure it helps others learn. This isn't about just getting answers and asking for stuff. It is about learning the code and how it functions in game without simply looking up definitions. People explain stuff in different ways. A wikipedia link gives you the definition sure, but it doesn't tell you how it is actually functioning in the above code. I am asking so that can see how @gummby8 explains it. The wiki link doesnt explain why he is using

i += 4;

or

 

if (facing >= 4) {
			facing -= 4;

etc. and then using 

return this.getDefaultState().withProperty(FACING, EnumFacing.getHorizontal(meta & 3)

Edited September 3, 20178 yr by HalestormXV

8 hours ago, gummby8 said:

They meta is always going to return 1 number

 

--snip--

 

That is a perfect explanation. Thank you. The forge docs wiki should have an example like that lol.

Edited September 3, 20178 yr by HalestormXV

TL;DR you're composing states into 4 bits worth of information and the decomposing those 4 bits back into states.

Booleans are 1 bit, integers are 1-4, depending on how many values they have (horizontal facing uses 2 bits, full facing uses 3).

Bitwise operators mask off the bits that aren't related to the bit(s) you care about.  & 3 means that only the lowest two bits retain their values:

  bx1010 //some arbitrary meta value

& bx0011 // & 3

========

  bx0010 //facing value (2)

Edited September 3, 20178 yr by Draco18s