Further simplify code for blocks with pages of variants. Remove test blocks
This commit is contained in:
parent
918dbdd5ff
commit
d6d75d7e40
|
@ -8,6 +8,12 @@
|
|||
|
||||
package biomesoplenty.api.block;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
import com.google.common.base.Predicate;
|
||||
|
||||
import net.minecraft.block.properties.PropertyEnum;
|
||||
import net.minecraft.util.IStringSerializable;
|
||||
|
||||
public class BOPTreeEnums
|
||||
|
@ -28,4 +34,51 @@ public class BOPTreeEnums
|
|||
}
|
||||
}
|
||||
|
||||
public static enum TreesFilterType {
|
||||
ALL, SAPLINGS;
|
||||
public Predicate<AllTrees> getPredicate(final int pageNum, final int numPerPage)
|
||||
{
|
||||
final TreesFilterType filterType = this;
|
||||
return new Predicate<AllTrees>()
|
||||
{
|
||||
@Override
|
||||
public boolean apply(AllTrees tree)
|
||||
{
|
||||
if (filterType == SAPLINGS && (tree == AllTrees.YELLOW_BIG_FLOWER || tree == AllTrees.RED_BIG_FLOWER) )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
return (tree.ordinal() >= (numPerPage * pageNum)) && (tree.ordinal() < (numPerPage * (pageNum+1)));
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
private static Map<Integer, PropertyEnum[]> propCache = new HashMap<Integer, PropertyEnum[]>();
|
||||
|
||||
public static PropertyEnum getVariantProperty(int pageNum, int numPerPage)
|
||||
{
|
||||
return getVariantProperty(pageNum, numPerPage, TreesFilterType.ALL);
|
||||
}
|
||||
|
||||
public static PropertyEnum getVariantProperty(int pageNum, int numPerPage, TreesFilterType filterType)
|
||||
{
|
||||
// check length and make sure things are in bounds
|
||||
int len = AllTrees.values().length;
|
||||
int numPages = (int) Math.ceil( (double)len / numPerPage);
|
||||
pageNum = Math.max(0, Math.min(pageNum, numPages - 1));
|
||||
|
||||
// look up the array of properties for pages of size numPerPage and the given filter - if it doesn't exist yet, create it
|
||||
Integer index = new Integer(numPerPage * TreesFilterType.values().length + filterType.ordinal() );
|
||||
if (!propCache.containsKey(index)) {propCache.put(index, new PropertyEnum[numPages]);}
|
||||
|
||||
// look up the property for page pageNum - if it doesn't exist yet, create it
|
||||
PropertyEnum[] propArr = propCache.get(index);
|
||||
if (propArr[pageNum] == null)
|
||||
{
|
||||
propArr[pageNum] = PropertyEnum.create("variant", AllTrees.class, filterType.getPredicate(pageNum, numPerPage));
|
||||
}
|
||||
return propArr[pageNum];
|
||||
}
|
||||
|
||||
}
|
|
@ -8,6 +8,12 @@
|
|||
|
||||
package biomesoplenty.api.block;
|
||||
|
||||
import java.util.HashMap;
|
||||
import java.util.Map;
|
||||
|
||||
import com.google.common.base.Predicate;
|
||||
|
||||
import net.minecraft.block.properties.PropertyEnum;
|
||||
import net.minecraft.util.IStringSerializable;
|
||||
|
||||
public class BOPWoodEnums
|
||||
|
@ -26,5 +32,56 @@ public class BOPWoodEnums
|
|||
return this.getName();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public static enum WoodsFilterType {
|
||||
ALL, WITH_PLANKS;
|
||||
public Predicate<AllWoods> getPredicate(final int pageNum, final int numPerPage)
|
||||
{
|
||||
final WoodsFilterType filterType = this;
|
||||
return new Predicate<AllWoods>()
|
||||
{
|
||||
@Override
|
||||
public boolean apply(AllWoods wood)
|
||||
{
|
||||
if (filterType == WITH_PLANKS && (wood == AllWoods.GIANT_FLOWER || wood == AllWoods.DEAD) )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
return (wood.ordinal() >= (numPerPage * pageNum)) && (wood.ordinal() < (numPerPage * (pageNum+1)));
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
private static Map<Integer, PropertyEnum[]> propCache = new HashMap<Integer, PropertyEnum[]>();
|
||||
|
||||
public static PropertyEnum getVariantProperty(int pageNum, int numPerPage)
|
||||
{
|
||||
return getVariantProperty(pageNum, numPerPage, WoodsFilterType.ALL);
|
||||
}
|
||||
|
||||
public static PropertyEnum getVariantProperty(int pageNum, int numPerPage, WoodsFilterType filterType)
|
||||
{
|
||||
// check length and make sure things are in bounds
|
||||
int len = AllWoods.values().length;
|
||||
int numPages = (int) Math.ceil( (double)len / numPerPage);
|
||||
pageNum = Math.max(0, Math.min(pageNum, numPages - 1));
|
||||
|
||||
// look up the array of properties for pages of size numPerPage and the given filter - if it doesn't exist yet, create it
|
||||
Integer index = new Integer(numPerPage * WoodsFilterType.values().length + filterType.ordinal() );
|
||||
if (!propCache.containsKey(index)) {propCache.put(index, new PropertyEnum[numPages]);}
|
||||
|
||||
// look up the property for page pageNum - if it doesn't exist yet, create it
|
||||
PropertyEnum[] propArr = propCache.get(index);
|
||||
if (propArr[pageNum] == null)
|
||||
{
|
||||
propArr[pageNum] = PropertyEnum.create("variant", AllWoods.class, filterType.getPredicate(pageNum, numPerPage));
|
||||
}
|
||||
return propArr[pageNum];
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
|
@ -2,9 +2,9 @@ package biomesoplenty.common.block;
|
|||
|
||||
import java.util.List;
|
||||
|
||||
import com.google.common.base.Predicate;
|
||||
import com.google.common.collect.ImmutableSet;
|
||||
|
||||
import biomesoplenty.api.block.BOPWoodEnums;
|
||||
import biomesoplenty.api.block.BOPWoodEnums.AllWoods;
|
||||
import biomesoplenty.api.block.IBOPBlock;
|
||||
import biomesoplenty.common.util.block.BlockStateUtils;
|
||||
|
@ -26,62 +26,33 @@ public abstract class BlockBOPHalfWoodSlab extends BlockSlab implements IBOPBloc
|
|||
{
|
||||
|
||||
|
||||
// store the variant properties for each page in this array
|
||||
private static PropertyEnum[] variantProperties;
|
||||
// number of variants per page - HALF requires 1 meta bit, so we have 3 left for the VARIANT, which means we can have eight woods per instance
|
||||
public static final int variantsPerPage = 8;
|
||||
// fetch a particular page's variant property
|
||||
// the first time this is called, it also sets up the array of variant properties
|
||||
protected static PropertyEnum getVariantProperty(int pageNum)
|
||||
{
|
||||
int len = AllWoods.values().length;
|
||||
int numPages = (int) Math.ceil( (double)len / variantsPerPage);
|
||||
if (variantProperties == null)
|
||||
{
|
||||
variantProperties = new PropertyEnum[numPages];
|
||||
}
|
||||
pageNum = Math.max(0, Math.min(pageNum, numPages - 1));
|
||||
if (variantProperties[pageNum] == null)
|
||||
{
|
||||
variantProperties[pageNum] = PropertyEnum.create("variant", AllWoods.class, getVariantEnumFilter(pageNum));
|
||||
}
|
||||
return variantProperties[pageNum];
|
||||
}
|
||||
// define the filter function used to reduce the set of enum values to the subset for the given page
|
||||
protected static Predicate<AllWoods> getVariantEnumFilter(final int pageNum)
|
||||
{
|
||||
return new Predicate<AllWoods>()
|
||||
{
|
||||
@Override
|
||||
public boolean apply(AllWoods wood)
|
||||
{
|
||||
switch (wood)
|
||||
{
|
||||
case GIANT_FLOWER: case DEAD:
|
||||
return false;
|
||||
default:
|
||||
return (wood.ordinal() >= (variantsPerPage * pageNum)) && (wood.ordinal() < (variantsPerPage * (pageNum+1)));
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
// setup paged variant property
|
||||
|
||||
// STAGE require one bit, so we have 3 bits left for the VARIANT which means we can have eight per instance
|
||||
public static final int VARIANTS_PER_PAGE = 8;
|
||||
// child classes must implement to define their page number
|
||||
abstract public int getPageNum();
|
||||
// fetch the variant property for a given page
|
||||
public static PropertyEnum getVariantProperty(int pageNum)
|
||||
{
|
||||
return BOPWoodEnums.getVariantProperty(pageNum, VARIANTS_PER_PAGE, BOPWoodEnums.WoodsFilterType.WITH_PLANKS);
|
||||
}
|
||||
// fetch the current instance's variant property
|
||||
public PropertyEnum getMyVariantProperty()
|
||||
{
|
||||
return getVariantProperty(this.getPageNum());
|
||||
return getVariantProperty(getPageNum());
|
||||
}
|
||||
// get the meta bits from the variant
|
||||
public int metaFromVariant(AllWoods wood)
|
||||
{
|
||||
return wood.ordinal() % variantsPerPage;
|
||||
return wood.ordinal() % VARIANTS_PER_PAGE;
|
||||
}
|
||||
// get the variant from meta bits (safely)
|
||||
public AllWoods variantFromMeta(int meta)
|
||||
{
|
||||
int i = Math.max(0, Math.min(meta + (this.getPageNum() * variantsPerPage), AllWoods.values().length)); // clamp to
|
||||
int i = Math.max(0, Math.min(meta + (this.getPageNum() * VARIANTS_PER_PAGE), AllWoods.values().length));
|
||||
return AllWoods.values()[i];
|
||||
}
|
||||
|
||||
|
||||
|
||||
// add properties (note we inherit HALF property from parent BlockSlab)
|
||||
|
|
|
@ -11,9 +11,8 @@ package biomesoplenty.common.block;
|
|||
import java.util.List;
|
||||
import java.util.Random;
|
||||
|
||||
import com.google.common.base.Predicate;
|
||||
|
||||
import biomesoplenty.api.block.BOPBlocks;
|
||||
import biomesoplenty.api.block.BOPTreeEnums;
|
||||
import biomesoplenty.api.block.IBOPBlock;
|
||||
import biomesoplenty.api.block.BOPTreeEnums.AllTrees;
|
||||
import biomesoplenty.common.item.ItemBOPBlock;
|
||||
|
@ -41,60 +40,33 @@ import net.minecraftforge.fml.relauncher.SideOnly;
|
|||
public abstract class BlockBOPLeaves extends BlockLeaves implements IBOPBlock
|
||||
{
|
||||
|
||||
// setup paged variant property
|
||||
|
||||
// store the variant properties for each page in this array
|
||||
private static PropertyEnum[] variantProperties;
|
||||
// CHECK_DECAY and DECAYABLE require one bit each, so we have 2 bits left for the VARIANT which means we can have four per instance
|
||||
public static final int variantsPerPage = 4;
|
||||
// fetch a particular page's variant property
|
||||
// the first time this is called, it also sets up the array of variant properties
|
||||
protected static PropertyEnum getVariantProperty(int pageNum)
|
||||
{
|
||||
int len = AllTrees.values().length;
|
||||
int numPages = (int) Math.ceil( (double)len / variantsPerPage);
|
||||
if (variantProperties == null)
|
||||
{
|
||||
variantProperties = new PropertyEnum[numPages];
|
||||
}
|
||||
pageNum = Math.max(0, Math.min(pageNum, numPages - 1));
|
||||
if (variantProperties[pageNum] == null)
|
||||
{
|
||||
variantProperties[pageNum] = PropertyEnum.create("variant", AllTrees.class, getVariantEnumFilter(pageNum));
|
||||
}
|
||||
return variantProperties[pageNum];
|
||||
}
|
||||
// define the filter function used to reduce the set of enum values to the subset for the given page
|
||||
protected static Predicate<AllTrees> getVariantEnumFilter(final int pageNum)
|
||||
{
|
||||
return new Predicate<AllTrees>()
|
||||
{
|
||||
@Override
|
||||
public boolean apply(AllTrees tree)
|
||||
{
|
||||
return (tree.ordinal() >= (variantsPerPage * pageNum)) && (tree.ordinal() < (variantsPerPage * (pageNum+1)));
|
||||
}
|
||||
};
|
||||
}
|
||||
public static final int VARIANTS_PER_PAGE = 4;
|
||||
// child classes must implement to define their page number
|
||||
abstract public int getPageNum();
|
||||
// fetch the variant property for a given page
|
||||
public static PropertyEnum getVariantProperty(int pageNum)
|
||||
{
|
||||
return BOPTreeEnums.getVariantProperty(pageNum, VARIANTS_PER_PAGE);
|
||||
}
|
||||
// fetch the current instance's variant property
|
||||
public PropertyEnum getMyVariantProperty()
|
||||
{
|
||||
return getVariantProperty(this.getPageNum());
|
||||
return getVariantProperty(getPageNum());
|
||||
}
|
||||
// get the meta bits from the variant
|
||||
public int metaFromVariant(AllTrees tree)
|
||||
{
|
||||
return tree.ordinal() % variantsPerPage;
|
||||
return tree.ordinal() % VARIANTS_PER_PAGE;
|
||||
}
|
||||
// get the variant from meta bits (safely)
|
||||
public AllTrees variantFromMeta(int meta)
|
||||
{
|
||||
int i = Math.max(0, Math.min(meta + (this.getPageNum() * variantsPerPage), AllTrees.values().length)); // clamp to
|
||||
int i = Math.max(0, Math.min(meta + (this.getPageNum() * VARIANTS_PER_PAGE), AllTrees.values().length));
|
||||
return AllTrees.values()[i];
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
// add properties - note CHECK_DECAY and DECAYABLE are both inherited from BlockLeaves
|
||||
@Override
|
||||
|
|
|
@ -8,9 +8,8 @@
|
|||
|
||||
package biomesoplenty.common.block;
|
||||
|
||||
import com.google.common.base.Predicate;
|
||||
|
||||
import biomesoplenty.api.block.BOPWoodEnums.AllWoods;
|
||||
import biomesoplenty.api.block.BOPWoodEnums;
|
||||
import biomesoplenty.api.block.IBOPBlock;
|
||||
import biomesoplenty.common.item.ItemBOPBlock;
|
||||
import net.minecraft.block.BlockLog;
|
||||
|
@ -23,57 +22,33 @@ import net.minecraft.item.ItemBlock;
|
|||
public abstract class BlockBOPLog extends BlockLog implements IBOPBlock
|
||||
{
|
||||
|
||||
// setup paged variant property
|
||||
|
||||
// store the variant properties for each page in this array
|
||||
private static PropertyEnum[] variantProperties;
|
||||
// number of variants per page
|
||||
public static final int variantsPerPage = 4;
|
||||
// fetch a particular page's variant property
|
||||
// the first time this is called, it also sets up the array of variant properties
|
||||
protected static PropertyEnum getVariantProperty(int pageNum)
|
||||
{
|
||||
int len = AllWoods.values().length;
|
||||
int numPages = (int) Math.ceil( (double)len / variantsPerPage);
|
||||
if (variantProperties == null)
|
||||
{
|
||||
variantProperties = new PropertyEnum[numPages];
|
||||
}
|
||||
pageNum = Math.max(0, Math.min(pageNum, numPages - 1));
|
||||
if (variantProperties[pageNum] == null)
|
||||
{
|
||||
variantProperties[pageNum] = PropertyEnum.create("variant", AllWoods.class, getVariantEnumFilter(pageNum));
|
||||
}
|
||||
return variantProperties[pageNum];
|
||||
}
|
||||
// define the filter function used to reduce the set of enum values to the subset for the given page
|
||||
protected static Predicate<AllWoods> getVariantEnumFilter(final int pageNum)
|
||||
{
|
||||
return new Predicate<AllWoods>()
|
||||
{
|
||||
@Override
|
||||
public boolean apply(AllWoods wood)
|
||||
{
|
||||
return (wood.ordinal() >= (variantsPerPage * pageNum)) && (wood.ordinal() < (variantsPerPage * (pageNum+1)));
|
||||
}
|
||||
};
|
||||
}
|
||||
// STAGE require one bit, so we have 3 bits left for the VARIANT which means we can have eight per instance
|
||||
public static final int VARIANTS_PER_PAGE = 4;
|
||||
// child classes must implement to define their page number
|
||||
abstract public int getPageNum();
|
||||
// fetch the variant property for a given page
|
||||
public static PropertyEnum getVariantProperty(int pageNum)
|
||||
{
|
||||
return BOPWoodEnums.getVariantProperty(pageNum, VARIANTS_PER_PAGE);
|
||||
}
|
||||
// fetch the current instance's variant property
|
||||
public PropertyEnum getMyVariantProperty()
|
||||
{
|
||||
return getVariantProperty(this.getPageNum());
|
||||
return getVariantProperty(getPageNum());
|
||||
}
|
||||
// get the meta bits from the variant
|
||||
public int metaFromVariant(AllWoods wood)
|
||||
{
|
||||
return wood.ordinal() % variantsPerPage;
|
||||
return wood.ordinal() % VARIANTS_PER_PAGE;
|
||||
}
|
||||
// get the variant from meta bits (safely)
|
||||
public AllWoods variantFromMeta(int meta)
|
||||
{
|
||||
int i = Math.max(0, Math.min(meta + (this.getPageNum() * variantsPerPage), AllWoods.values().length)); // clamp to
|
||||
int i = Math.max(0, Math.min(meta + (this.getPageNum() * VARIANTS_PER_PAGE), AllWoods.values().length));
|
||||
return AllWoods.values()[i];
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
@Override
|
||||
protected BlockState createBlockState() {return new BlockState(this, new IProperty[] { LOG_AXIS, getMyVariantProperty() });}
|
||||
|
|
|
@ -8,8 +8,6 @@
|
|||
|
||||
package biomesoplenty.common.block;
|
||||
|
||||
import com.google.common.base.Predicate;
|
||||
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.block.material.Material;
|
||||
import net.minecraft.block.properties.IProperty;
|
||||
|
@ -17,6 +15,7 @@ import net.minecraft.block.properties.PropertyEnum;
|
|||
import net.minecraft.block.state.BlockState;
|
||||
import net.minecraft.block.state.IBlockState;
|
||||
import net.minecraft.item.ItemBlock;
|
||||
import biomesoplenty.api.block.BOPWoodEnums;
|
||||
import biomesoplenty.api.block.IBOPBlock;
|
||||
import biomesoplenty.api.block.BOPWoodEnums.AllWoods;
|
||||
import biomesoplenty.common.item.ItemBOPBlock;
|
||||
|
@ -24,64 +23,33 @@ import biomesoplenty.common.item.ItemBOPBlock;
|
|||
public abstract class BlockBOPPlanks extends Block implements IBOPBlock
|
||||
{
|
||||
|
||||
// setup paged variant property
|
||||
|
||||
// store the variant properties for each page in this array
|
||||
private static PropertyEnum[] variantProperties;
|
||||
// number of variants per page - all 4 meta bits are available so we can have 16
|
||||
public static final int variantsPerPage = 16;
|
||||
// fetch a particular page's variant property
|
||||
// the first time this is called, it also sets up the array of variant properties
|
||||
protected static PropertyEnum getVariantProperty(int pageNum)
|
||||
{
|
||||
int len = AllWoods.values().length;
|
||||
int numPages = (int) Math.ceil( (double)len / variantsPerPage);
|
||||
if (variantProperties == null)
|
||||
{
|
||||
variantProperties = new PropertyEnum[numPages];
|
||||
}
|
||||
pageNum = Math.max(0, Math.min(pageNum, numPages - 1));
|
||||
if (variantProperties[pageNum] == null)
|
||||
{
|
||||
variantProperties[pageNum] = PropertyEnum.create("variant", AllWoods.class, getVariantEnumFilter(pageNum));
|
||||
}
|
||||
return variantProperties[pageNum];
|
||||
}
|
||||
// define the filter function used to reduce the set of enum values to the subset for the given page
|
||||
protected static Predicate<AllWoods> getVariantEnumFilter(final int pageNum)
|
||||
{
|
||||
return new Predicate<AllWoods>()
|
||||
{
|
||||
@Override
|
||||
public boolean apply(AllWoods wood)
|
||||
{
|
||||
switch (wood)
|
||||
{
|
||||
case GIANT_FLOWER: case DEAD:
|
||||
return false;
|
||||
default:
|
||||
return (wood.ordinal() >= (variantsPerPage * pageNum)) && (wood.ordinal() < (variantsPerPage * (pageNum+1)));
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
// STAGE require one bit, so we have 3 bits left for the VARIANT which means we can have eight per instance
|
||||
public static final int VARIANTS_PER_PAGE = 16;
|
||||
// child classes must implement to define their page number
|
||||
abstract public int getPageNum();
|
||||
// fetch the variant property for a given page
|
||||
public static PropertyEnum getVariantProperty(int pageNum)
|
||||
{
|
||||
return BOPWoodEnums.getVariantProperty(pageNum, VARIANTS_PER_PAGE, BOPWoodEnums.WoodsFilterType.WITH_PLANKS);
|
||||
}
|
||||
// fetch the current instance's variant property
|
||||
public PropertyEnum getMyVariantProperty()
|
||||
{
|
||||
return getVariantProperty(this.getPageNum());
|
||||
return getVariantProperty(getPageNum());
|
||||
}
|
||||
// get the meta bits from the variant
|
||||
public int metaFromVariant(AllWoods wood)
|
||||
{
|
||||
return wood.ordinal() % variantsPerPage;
|
||||
return wood.ordinal() % VARIANTS_PER_PAGE;
|
||||
}
|
||||
// get the variant from meta bits (safely)
|
||||
public AllWoods variantFromMeta(int meta)
|
||||
{
|
||||
int i = Math.max(0, Math.min(meta + (this.getPageNum() * variantsPerPage), AllWoods.values().length)); // clamp to
|
||||
int i = Math.max(0, Math.min(meta + (this.getPageNum() * VARIANTS_PER_PAGE), AllWoods.values().length));
|
||||
return AllWoods.values()[i];
|
||||
}
|
||||
|
||||
|
||||
|
||||
// add properties (note we inherit LOG_AXIS property from parent BlockLog)
|
||||
@Override
|
||||
|
|
|
@ -10,9 +10,8 @@ package biomesoplenty.common.block;
|
|||
|
||||
import java.util.Random;
|
||||
|
||||
import com.google.common.base.Predicate;
|
||||
|
||||
import biomesoplenty.api.block.BOPBlocks;
|
||||
import biomesoplenty.api.block.BOPTreeEnums;
|
||||
import biomesoplenty.api.block.BOPTreeEnums.AllTrees;
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.block.IGrowable;
|
||||
|
@ -30,66 +29,36 @@ import net.minecraft.world.gen.feature.WorldGenerator;
|
|||
|
||||
public abstract class BlockBOPSapling extends BlockDecoration implements IGrowable {
|
||||
|
||||
|
||||
// setup paged variant property
|
||||
|
||||
// store the variant properties for each page in this array
|
||||
private static PropertyEnum[] variantProperties;
|
||||
// STAGE require one bit, so we have 3 bits left for the VARIANT which means we can have eight per instance
|
||||
public static final int variantsPerPage = 8;
|
||||
// fetch a particular page's variant property
|
||||
// the first time this is called, it also sets up the array of variant properties
|
||||
protected static PropertyEnum getVariantProperty(int pageNum)
|
||||
{
|
||||
int len = AllTrees.values().length;
|
||||
int numPages = (int) Math.ceil( (double)len / variantsPerPage);
|
||||
if (variantProperties == null)
|
||||
{
|
||||
variantProperties = new PropertyEnum[numPages];
|
||||
}
|
||||
pageNum = Math.max(0, Math.min(pageNum, numPages - 1));
|
||||
if (variantProperties[pageNum] == null)
|
||||
{
|
||||
variantProperties[pageNum] = PropertyEnum.create("variant", AllTrees.class, getVariantEnumFilter(pageNum));
|
||||
}
|
||||
return variantProperties[pageNum];
|
||||
}
|
||||
// define the filter function used to reduce the set of enum values to the subset for the given page
|
||||
protected static Predicate<AllTrees> getVariantEnumFilter(final int pageNum)
|
||||
{
|
||||
return new Predicate<AllTrees>()
|
||||
{
|
||||
@Override
|
||||
public boolean apply(AllTrees tree)
|
||||
{
|
||||
switch (tree)
|
||||
{
|
||||
case RED_BIG_FLOWER: case YELLOW_BIG_FLOWER:
|
||||
return false;
|
||||
default:
|
||||
return (tree.ordinal() >= (variantsPerPage * pageNum)) && (tree.ordinal() < (variantsPerPage * (pageNum+1)));
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
public static final int VARIANTS_PER_PAGE = 8;
|
||||
// child classes must implement to define their page number
|
||||
abstract public int getPageNum();
|
||||
// fetch the variant property for a given page
|
||||
public static PropertyEnum getVariantProperty(int pageNum)
|
||||
{
|
||||
return BOPTreeEnums.getVariantProperty(pageNum, VARIANTS_PER_PAGE, BOPTreeEnums.TreesFilterType.SAPLINGS);
|
||||
}
|
||||
// fetch the current instance's variant property
|
||||
public PropertyEnum getMyVariantProperty()
|
||||
{
|
||||
return getVariantProperty(this.getPageNum());
|
||||
return getVariantProperty(getPageNum());
|
||||
}
|
||||
// get the meta bits from the variant
|
||||
public int metaFromVariant(AllTrees tree)
|
||||
{
|
||||
return tree.ordinal() % variantsPerPage;
|
||||
return tree.ordinal() % VARIANTS_PER_PAGE;
|
||||
}
|
||||
// get the variant from meta bits (safely)
|
||||
public AllTrees variantFromMeta(int meta)
|
||||
{
|
||||
int i = Math.max(0, Math.min(meta + (this.getPageNum() * variantsPerPage), AllTrees.values().length)); // clamp to
|
||||
int i = Math.max(0, Math.min(meta + (this.getPageNum() * VARIANTS_PER_PAGE), AllTrees.values().length));
|
||||
return AllTrees.values()[i];
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
// add properties
|
||||
public static final PropertyInteger STAGE = PropertyInteger.create("stage", 0, 1);
|
||||
@Override
|
||||
|
|
|
@ -1,116 +0,0 @@
|
|||
/*******************************************************************************
|
||||
* Copyright 2014, the Biomes O' Plenty Team
|
||||
*
|
||||
* This work is licensed under a Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International Public License.
|
||||
*
|
||||
* To view a copy of this license, visit http://creativecommons.org/licenses/by-nc-nd/4.0/.
|
||||
******************************************************************************/
|
||||
|
||||
package biomesoplenty.common.block;
|
||||
|
||||
import com.google.common.base.Predicate;
|
||||
|
||||
import net.minecraft.block.Block;
|
||||
import net.minecraft.block.material.Material;
|
||||
import net.minecraft.block.properties.IProperty;
|
||||
import net.minecraft.block.properties.PropertyEnum;
|
||||
import net.minecraft.block.state.BlockState;
|
||||
import net.minecraft.block.state.IBlockState;
|
||||
import net.minecraft.util.IStringSerializable;
|
||||
|
||||
public abstract class BlockCheese extends Block
|
||||
{
|
||||
|
||||
public enum AllCheeses implements IStringSerializable
|
||||
{
|
||||
CHEDDAR, EDAM, MOZARELLA, STILTON, PARMESAN, BRIE, LANCS, WENSLEYDALE, GRUYERE, COMTE;
|
||||
@Override
|
||||
public String getName()
|
||||
{
|
||||
return this.name().toLowerCase();
|
||||
}
|
||||
@Override
|
||||
public String toString()
|
||||
{
|
||||
return this.getName();
|
||||
}
|
||||
}
|
||||
|
||||
// store the variant properties for each page in this array
|
||||
private static PropertyEnum[] variantProperties;
|
||||
// number of variants per page
|
||||
public static final int variantsPerPage = 4;
|
||||
// fetch a particular page's variant property
|
||||
// the first time this is called, it also sets up the array of variant properties
|
||||
protected static PropertyEnum getVariantProperty(int pageNum)
|
||||
{
|
||||
int len = AllCheeses.values().length;
|
||||
int numPages = (int) Math.ceil( (double)len / variantsPerPage);
|
||||
if (variantProperties == null)
|
||||
{
|
||||
variantProperties = new PropertyEnum[numPages];
|
||||
}
|
||||
pageNum = Math.max(0, Math.min(pageNum, numPages - 1));
|
||||
if (variantProperties[pageNum] == null)
|
||||
{
|
||||
variantProperties[pageNum] = PropertyEnum.create("variant", AllCheeses.class, getVariantEnumFilter(pageNum));
|
||||
}
|
||||
return variantProperties[pageNum];
|
||||
}
|
||||
// child classes must implement to define their page number
|
||||
abstract public int getPageNum();
|
||||
// fetch the current instance's variant property
|
||||
public PropertyEnum getMyVariantProperty()
|
||||
{
|
||||
return getVariantProperty(this.getPageNum());
|
||||
}
|
||||
// define the filter function used to reduce the set of enum values to the subset for the given page
|
||||
protected static Predicate<AllCheeses> getVariantEnumFilter(final int pageNum)
|
||||
{
|
||||
return new Predicate<AllCheeses>()
|
||||
{
|
||||
@Override
|
||||
public boolean apply(AllCheeses cheese)
|
||||
{
|
||||
return (cheese.ordinal() >= (variantsPerPage * pageNum)) && (cheese.ordinal() < (variantsPerPage * (pageNum+1)));
|
||||
}
|
||||
};
|
||||
}
|
||||
public int metaFromVariant(AllCheeses type)
|
||||
{
|
||||
return type.ordinal() % variantsPerPage;
|
||||
}
|
||||
public AllCheeses variantFromMeta(int meta)
|
||||
{
|
||||
int i = Math.max(0, Math.min(meta + (this.getPageNum() * variantsPerPage), AllCheeses.values().length)); // clamp to
|
||||
return AllCheeses.values()[i];
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
@Override
|
||||
protected BlockState createBlockState()
|
||||
{
|
||||
return new BlockState(this, new IProperty[] { getMyVariantProperty() });
|
||||
}
|
||||
|
||||
public BlockCheese()
|
||||
{
|
||||
super(Material.cake);
|
||||
}
|
||||
|
||||
// map from state to meta and vice verca
|
||||
@Override
|
||||
public IBlockState getStateFromMeta(int meta)
|
||||
{
|
||||
return this.getDefaultState().withProperty(getMyVariantProperty(), variantFromMeta(meta & 3)); // in addition to other properties
|
||||
}
|
||||
@Override
|
||||
public int getMetaFromState(IBlockState state)
|
||||
{
|
||||
return metaFromVariant((AllCheeses) state.getValue(getMyVariantProperty())); // plus bits from other properties
|
||||
}
|
||||
|
||||
|
||||
}
|
|
@ -1,17 +0,0 @@
|
|||
package biomesoplenty.common.block;
|
||||
|
||||
import net.minecraft.block.properties.PropertyEnum;
|
||||
|
||||
public class BlockCheese0 extends BlockCheese
|
||||
{
|
||||
|
||||
public static final int PAGENUM = 0;
|
||||
|
||||
// create a static reference to this block's variant property
|
||||
// this is for convenience, and for consistency with other Block classes
|
||||
public static final PropertyEnum VARIANT = BlockCheese.getVariantProperty(PAGENUM);
|
||||
|
||||
@Override
|
||||
public int getPageNum() {return PAGENUM;}
|
||||
|
||||
}
|
|
@ -1,17 +0,0 @@
|
|||
package biomesoplenty.common.block;
|
||||
|
||||
import net.minecraft.block.properties.PropertyEnum;
|
||||
|
||||
public class BlockCheese1 extends BlockCheese
|
||||
{
|
||||
|
||||
public static final int PAGENUM = 1;
|
||||
|
||||
// create a static reference to this block's variant property
|
||||
// this is for convenience, and for consistency with other Block classes
|
||||
public static final PropertyEnum VARIANT = BlockCheese.getVariantProperty(PAGENUM);
|
||||
|
||||
@Override
|
||||
public int getPageNum() {return PAGENUM;}
|
||||
|
||||
}
|
Loading…
Reference in New Issue