From 70c1354a4a96698758a88c032866288f79de6f5a Mon Sep 17 00:00:00 2001 From: Benjamin Culkin Date: Sat, 24 Aug 2024 08:16:37 -0400 Subject: Initial commit --- .../jp/plusplus/fbs/pottery/BlockPotteryBase.java | 361 +++++++++++++++++++++ 1 file changed, 361 insertions(+) create mode 100644 src/main/java/jp/plusplus/fbs/pottery/BlockPotteryBase.java (limited to 'src/main/java/jp/plusplus/fbs/pottery/BlockPotteryBase.java') diff --git a/src/main/java/jp/plusplus/fbs/pottery/BlockPotteryBase.java b/src/main/java/jp/plusplus/fbs/pottery/BlockPotteryBase.java new file mode 100644 index 0000000..9c95030 --- /dev/null +++ b/src/main/java/jp/plusplus/fbs/pottery/BlockPotteryBase.java @@ -0,0 +1,361 @@ +package jp.plusplus.fbs.pottery; + +import cpw.mods.fml.relauncher.Side; +import cpw.mods.fml.relauncher.SideOnly; +import jp.plusplus.fbs.FBS; +import jp.plusplus.fbs.api.IPottery; +import jp.plusplus.fbs.block.BlockBase; +import jp.plusplus.fbs.block.BlockCore; +import jp.plusplus.fbs.pottery.usable.PotteryBase; +import net.minecraft.block.Block; +import net.minecraft.block.ITileEntityProvider; +import net.minecraft.block.material.Material; +import net.minecraft.client.model.ModelBase; +import net.minecraft.creativetab.CreativeTabs; +import net.minecraft.entity.player.EntityPlayer; +import net.minecraft.item.Item; +import net.minecraft.item.ItemStack; +import net.minecraft.nbt.NBTTagCompound; +import net.minecraft.tileentity.TileEntity; +import net.minecraft.util.MovingObjectPosition; +import net.minecraft.util.ResourceLocation; +import net.minecraft.util.StatCollector; +import net.minecraft.world.IBlockAccess; +import net.minecraft.world.World; + +import java.util.ArrayList; +import java.util.List; +import java.util.Random; + +/** + * Created by plusplus_F on 2015/08/26. + * + * INT型8byteのうち、 + * 0xVWXYZZ + * V:hasEffect + * W:state + * X:grade + * Y:size + * Z:pattern + * + */ +public abstract class BlockPotteryBase extends BlockBase implements IPottery,ITileEntityProvider{ + + public static final String EFFECT_ID ="PotteryID"; + public String typeName; + public int baseValue; + + public BlockPotteryBase(String t, int value) { + super(Material.glass); + typeName="pottery.fbs."+t; + baseValue=value; + + setBlockName(t); + setBlockTextureName("flower_pot"); + setCreativeTab(FBS.tabPottery); + } + + @Override + public int getRenderType(){ + return FBS.renderJarId; + } + @Override + public boolean renderAsNormalBlock(){ + return false; + } + @Override + public boolean isOpaqueCube() { + return false; + } + @SideOnly(Side.CLIENT) + public boolean shouldSideBeRendered(IBlockAccess p_149646_1_, int p_149646_2_, int p_149646_3_, int p_149646_4_, int p_149646_5_) { + return true; + } + + @SideOnly(Side.CLIENT) + public void getSubBlocks(Item item, CreativeTabs tab, List list) { + ArrayList meta=getAllPattern(); + for(ItemStack m : meta){ + list.add(m); + } + } + + @Override + public TileEntity createNewTileEntity(World p_149915_1_, int p_149915_2_) { + return new TileEntityPottery(); + } + + @Override + public ArrayList getDrops(World world, int x, int y, int z, int metadata, int fortune) { + ArrayList ret = new ArrayList(); + + TileEntity entity=world.getTileEntity(x,y,z); + if(entity instanceof TileEntityPottery){ + TileEntityPottery te=(TileEntityPottery)entity; + ItemStack item=new ItemStack(Item.getItemFromBlock(this), 1, te.getMetadata()); + NBTTagCompound nbt=new NBTTagCompound(); + te.writePotteryData(nbt); + item.setTagCompound(nbt); + ret.add(item); + } + + return ret; + } + + @Override + public void breakBlock(World world, int x, int y, int z, Block block, int p_149749_6_) { + + TileEntity entity=world.getTileEntity(x,y,z); + if(entity instanceof TileEntityPottery){ + TileEntityPottery te=(TileEntityPottery)entity; + dropBlockAsItemWithChance(world, x, y, z, te.getMetadata(), 1.0f, 0); + //ret.add(new ItemStack(Item.getItemFromBlock(this), 1, te.potteryMetadata)); + } + + //p_149749_1_.func_147480_a() + super.breakBlock(world, x, y, z, block, p_149749_6_); + } + + @Override + public ItemStack getPickBlock(MovingObjectPosition target, World world, int x, int y, int z, EntityPlayer player) { + TileEntity entity=world.getTileEntity(x,y,z); + if(entity instanceof TileEntityPottery){ + TileEntityPottery te=(TileEntityPottery)entity; + ItemStack ret=new ItemStack(Item.getItemFromBlock(this), 1, te.getMetadata()); + te.writePotteryData(getNBT(ret)); + return ret; + } + return new ItemStack(Item.getItemFromBlock(this)); + } + + /** + * Gradeによる価格補正倍率を得る + * @param grade + * @return + */ + public float getRateWithGrade(PotteryGrade grade){ + float ext; + switch (grade){ + case BAD: ext=0.75f; break; + case GOOD: ext=1.5f; break; + case GREAT: ext=4.0f; break; + case SOULFUL: ext=12.0f; break; + default: ext=1.f; break; + } + return ext; + } + + /** + * Sizeによる価格補正倍率を得る + * @param size + * @return + */ + public float getRateWithSize(PotterySize size){ + float ext; + switch (size){ + case SMALL: ext=0.5f; break; + case LARGE: ext=2.0f; break; + default: ext=1.f; break; + } + return ext; + } + + public String getPrefixWithPattern(int pattern){ + String str; + switch (pattern){ + case 1: str=StatCollector.translateToLocal("pottery.fbs.linear"); break; + case 2: str=StatCollector.translateToLocal("pottery.fbs.mesh"); break; + case 3: str=StatCollector.translateToLocal("pottery.fbs.flower"); break; + default: str=StatCollector.translateToLocal("pottery.fbs.plain"); break; + } + return str; + } + + //継承用 + public String getPotteryName(NBTTagCompound nbt){ + return StatCollector.translateToLocal(typeName); + } + + public NBTTagCompound getNBT(ItemStack itemStack){ + if(!itemStack.hasTagCompound()) itemStack.setTagCompound(new NBTTagCompound()); + return itemStack.getTagCompound(); + } + + //------------------------------- IPottery ---------------------------------------- + @Override + public ItemStack getItemStack(PotteryState state, PotteryGrade grade, PotterySize size, byte pattern, boolean hasEffect){ + ItemStack dummy=new ItemStack(this); + setState(dummy, state); + setGrade(dummy, grade); + setSize(dummy, size); + setPattern(dummy, pattern); + setEffect(dummy, hasEffect); + dummy.setItemDamage(getMetadata(dummy.getTagCompound())); + return dummy; + } + + @Override + public void setSize(ItemStack itemStack, PotterySize size){ + NBTTagCompound nbt=getNBT(itemStack); + if(nbt.hasKey("size")) nbt.removeTag("size"); + nbt.setByte("size", size.getValue()); + } + @Override + public PotterySize getSize(NBTTagCompound nbt) { + if(!nbt.hasKey("size")) return PotterySize.MEDIUM; + return PotterySize.Get(nbt.getByte("size")); + } + + @Override + public void setGrade(ItemStack itemStack, PotteryGrade grade){ + NBTTagCompound nbt=getNBT(itemStack); + if(nbt.hasKey("grade")) nbt.removeTag("grade"); + nbt.setByte("grade", grade.getValue()); + } + @Override + public void setGrade(ItemStack itemStack, Random rand){ + float r=rand.nextFloat(); + PotteryGrade g; + + if(r<=0.05f) g=PotteryGrade.SOULFUL; + else if(r<=0.05f+0.10f) g=PotteryGrade.GREAT; + else if(r<=0.15f+0.25f) g=PotteryGrade.GOOD; + else if(r<=0.40f+0.15f) g=PotteryGrade.BAD; + else g=PotteryGrade.NORMAL; + + setGrade(itemStack, g); + } + @Override + public PotteryGrade getGrade(NBTTagCompound nbt){ + if(!nbt.hasKey("grade")) return PotteryGrade.NORMAL; + return PotteryGrade.Get(nbt.getByte("grade")); + } + + @Override + public void setPattern(ItemStack itemStack, byte pattern){ + NBTTagCompound nbt=getNBT(itemStack); + nbt.setByte("pattern", pattern); + } + @Override + public byte getPattern(NBTTagCompound nbt){ + if(!nbt.hasKey("pattern")) return 0; + return nbt.getByte("pattern"); + } + + @Override + public void setState(ItemStack itemStack, PotteryState state){ + NBTTagCompound nbt=getNBT(itemStack); + if(nbt.hasKey("state")) nbt.removeTag("state"); + nbt.setByte("state", state.getValue()); + } + @Override + public PotteryState getState(NBTTagCompound nbt){ + if(!nbt.hasKey("state")) return PotteryState.BAKED; + return PotteryState.Get(nbt.getByte("state")); + } + + @Override + public void setEffect(ItemStack itemStack, boolean eff){ + NBTTagCompound nbt=getNBT(itemStack); + if(nbt.hasKey("hasEffect")) nbt.removeTag("hasEffect"); + nbt.setBoolean("hasEffect", eff); + } + @Override + public boolean hasEffect(NBTTagCompound nbt){ + if(!nbt.hasKey("hasEffect")) return false; + return nbt.getBoolean("hasEffect"); + } + + @Override + public abstract ResourceLocation getResourceLocation(int metadata); + + @Override + public abstract ModelBase getModel(int metadata); + + @Override + public Block getBlockType() { + return this; + } + + @Override + public int getDrySec(NBTTagCompound nbt){ + PotterySize size=getSize(nbt); + if(size==PotterySize.SMALL) return 5*60; + if(size==PotterySize.LARGE) return 20*60; + return 12*60; + } + + @Override + public int getMP(ItemStack itemStack) { + NBTTagCompound nbt=getNBT(itemStack); + if(getState(nbt)!=PotteryState.BAKED) return 0; + return (int)(getRateWithGrade(getGrade(nbt))*getRateWithSize(getSize(nbt))*baseValue); + } + + @Override + public int getMetadata(NBTTagCompound nbt){ + int meta=(nbt.getByte("pattern")%0xf); + meta=(meta|(nbt.getByte("state")<<6)); + meta=(meta|(nbt.getByte("size")<<4)); + meta=(meta|(nbt.getByte("grade")<<8)); + return meta; + } + + @Override + public String getLocalizedName(NBTTagCompound nbt) { + PotteryState state=getState(nbt); + String stString=PotteryState.GetLocalizedPrefix(state); + String grade=PotteryGrade.GetLocalizedPrefix(getGrade(nbt)); + String size=PotterySize.GetLocalizedPrefix(getSize(nbt)); + String pattern=getPrefixWithPattern(getPattern(nbt)); + + if(StatCollector.canTranslate("locale.fbs.jp")){ + if(state==PotteryState.BAKED) return stString+grade+pattern+size; + return stString+pattern+size; + } + else{ + if(state==PotteryState.BAKED) return (grade.isEmpty()?"":grade+" ")+pattern+" "+(size.isEmpty()?"":size+" "); + return stString+" "+pattern+" "+(size.isEmpty()?"":size+" "); + } + } + + @Override + public ArrayList getAllPattern() { + ArrayList ret = new ArrayList(); + + for (int g = 1; g < 2; g++) { + for (int p = 0; p < 4; p++) { + for (int s = 0; s < 3; s++) { + NBTTagCompound nbt = new NBTTagCompound(); + nbt.setByte("state", PotteryState.BAKED.getValue()); + nbt.setByte("grade", (byte) g); + nbt.setByte("size", (byte) s); + nbt.setByte("pattern", (byte) p); + + ItemStack tmp = new ItemStack(this, 1, getMetadata(nbt)); + tmp.setTagCompound(nbt); + ret.add(tmp); + //ret.add(((g<<12)|(s<<8)|p)); + } + } + } + return ret; + } + + @Override + public float getCrashProbability(ItemStack itemStack){ + NBTTagCompound nbt=BlockCore.pot.getNBT(itemStack); + + //割れない壺は割れない + if(hasEffect(nbt) && getState(nbt)==PotteryState.BAKED){ + PotteryBase pb=PotteryRegistry.getPotteryEffect(nbt.getInteger(EFFECT_ID)); + if(pb.getUnlocalizedName().equals("pottery.fbs.pot.unbreakable")) return 0; + } + + //壺の大きさで割れやすさが変わる + PotterySize size = getSize(nbt); + if (size == PotterySize.SMALL) return 0.05f; + if (size == PotterySize.LARGE) return 0.35f; + return 0.15f; + } +} -- cgit v1.2.3