diff --git a/packages/world/script/initObjects.sol b/packages/world/script/initObjects.sol index d8126933..ae842cff 100644 --- a/packages/world/script/initObjects.sol +++ b/packages/world/script/initObjects.sol @@ -225,6 +225,108 @@ function initObjects() { ObjectPhysics.set(ObjectTypes.Paper, ObjectPhysicsData({ mass: 200000000000000, energy: 0 })); ObjectPhysics.set(ObjectTypes.Stick, ObjectPhysicsData({ mass: 2250000000000000, energy: 0 })); ObjectPhysics.set(ObjectTypes.Lodestone, ObjectPhysicsData({ mass: 771000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.StoneStairs, ObjectPhysicsData({ mass: 12000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.CobblestoneStairs, ObjectPhysicsData({ mass: 22500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.MossyCobblestoneStairs, ObjectPhysicsData({ mass: 37500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.StoneBricksStairs, ObjectPhysicsData({ mass: 12000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.SmoothStoneStairs, ObjectPhysicsData({ mass: 12000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.AndesiteStairs, ObjectPhysicsData({ mass: 15000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.GraniteStairs, ObjectPhysicsData({ mass: 15000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.DioriteStairs, ObjectPhysicsData({ mass: 18000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.TuffStairs, ObjectPhysicsData({ mass: 15000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.BasaltStairs, ObjectPhysicsData({ mass: 75000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.BlackstoneStairs, ObjectPhysicsData({ mass: 50000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.PolishedAndesiteStairs, ObjectPhysicsData({ mass: 15000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.PolishedGraniteStairs, ObjectPhysicsData({ mass: 15000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.PolishedDioriteStairs, ObjectPhysicsData({ mass: 18000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.PolishedTuffStairs, ObjectPhysicsData({ mass: 15000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.PolishedBasaltStairs, ObjectPhysicsData({ mass: 75000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.PolishedBlackstoneStairs, ObjectPhysicsData({ mass: 50000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.DeepslateStairs, ObjectPhysicsData({ mass: 40000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.CobbledDeepslateStairs, ObjectPhysicsData({ mass: 100000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.DeepslateBricksStairs, ObjectPhysicsData({ mass: 100000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.SandstoneStairs, ObjectPhysicsData({ mass: 30000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.RedSandstoneStairs, ObjectPhysicsData({ mass: 37500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.SmoothSandstoneStairs, ObjectPhysicsData({ mass: 30000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.SmoothRedSandstoneStairs, ObjectPhysicsData({ mass: 37500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.BrickBlockStairs, ObjectPhysicsData({ mass: 9600000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.MudBricksStairs, ObjectPhysicsData({ mass: 5000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.TuffBricksStairs, ObjectPhysicsData({ mass: 15000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.OakPlanksStairs, ObjectPhysicsData({ mass: 4500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.BirchPlanksStairs, ObjectPhysicsData({ mass: 4500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.JunglePlanksStairs, ObjectPhysicsData({ mass: 4500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.SakuraPlanksStairs, ObjectPhysicsData({ mass: 4500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.AcaciaPlanksStairs, ObjectPhysicsData({ mass: 4500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.SprucePlanksStairs, ObjectPhysicsData({ mass: 4500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.DarkOakPlanksStairs, ObjectPhysicsData({ mass: 4500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.MangrovePlanksStairs, ObjectPhysicsData({ mass: 4500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.StoneSlab, ObjectPhysicsData({ mass: 6000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.CobblestoneSlab, ObjectPhysicsData({ mass: 11250000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.MossyCobblestoneSlab, ObjectPhysicsData({ mass: 18750000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.StoneBricksSlab, ObjectPhysicsData({ mass: 6000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.SmoothStoneSlab, ObjectPhysicsData({ mass: 6000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.AndesiteSlab, ObjectPhysicsData({ mass: 7500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.GraniteSlab, ObjectPhysicsData({ mass: 7500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.DioriteSlab, ObjectPhysicsData({ mass: 9000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.TuffSlab, ObjectPhysicsData({ mass: 7500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.BasaltSlab, ObjectPhysicsData({ mass: 37500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.BlackstoneSlab, ObjectPhysicsData({ mass: 25000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.PolishedAndesiteSlab, ObjectPhysicsData({ mass: 7500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.PolishedGraniteSlab, ObjectPhysicsData({ mass: 7500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.PolishedDioriteSlab, ObjectPhysicsData({ mass: 9000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.PolishedTuffSlab, ObjectPhysicsData({ mass: 7500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.PolishedBasaltSlab, ObjectPhysicsData({ mass: 37500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.PolishedBlackstoneSlab, ObjectPhysicsData({ mass: 25000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.DeepslateSlab, ObjectPhysicsData({ mass: 20000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.CobbledDeepslateSlab, ObjectPhysicsData({ mass: 50000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.DeepslateBricksSlab, ObjectPhysicsData({ mass: 50000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.SandstoneSlab, ObjectPhysicsData({ mass: 15000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.RedSandstoneSlab, ObjectPhysicsData({ mass: 18750000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.SmoothSandstoneSlab, ObjectPhysicsData({ mass: 15000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.SmoothRedSandstoneSlab, ObjectPhysicsData({ mass: 18750000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.BrickBlockSlab, ObjectPhysicsData({ mass: 4800000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.MudBricksSlab, ObjectPhysicsData({ mass: 2500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.TuffBricksSlab, ObjectPhysicsData({ mass: 7500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.OakPlanksSlab, ObjectPhysicsData({ mass: 2250000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.BirchPlanksSlab, ObjectPhysicsData({ mass: 2250000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.JunglePlanksSlab, ObjectPhysicsData({ mass: 2250000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.SakuraPlanksSlab, ObjectPhysicsData({ mass: 2250000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.AcaciaPlanksSlab, ObjectPhysicsData({ mass: 2250000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.SprucePlanksSlab, ObjectPhysicsData({ mass: 2250000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.DarkOakPlanksSlab, ObjectPhysicsData({ mass: 2250000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.MangrovePlanksSlab, ObjectPhysicsData({ mass: 2250000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.StoneWall, ObjectPhysicsData({ mass: 12000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.CobblestoneWall, ObjectPhysicsData({ mass: 22500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.MossyCobblestoneWall, ObjectPhysicsData({ mass: 37500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.StoneBricksWall, ObjectPhysicsData({ mass: 12000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.AndesiteWall, ObjectPhysicsData({ mass: 15000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.GraniteWall, ObjectPhysicsData({ mass: 15000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.DioriteWall, ObjectPhysicsData({ mass: 18000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.TuffWall, ObjectPhysicsData({ mass: 15000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.BasaltWall, ObjectPhysicsData({ mass: 75000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.BlackstoneWall, ObjectPhysicsData({ mass: 50000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.PolishedAndesiteWall, ObjectPhysicsData({ mass: 15000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.PolishedGraniteWall, ObjectPhysicsData({ mass: 15000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.PolishedDioriteWall, ObjectPhysicsData({ mass: 18000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.PolishedTuffWall, ObjectPhysicsData({ mass: 15000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.PolishedBasaltWall, ObjectPhysicsData({ mass: 75000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.PolishedBlackstoneWall, ObjectPhysicsData({ mass: 50000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.DeepslateWall, ObjectPhysicsData({ mass: 40000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.CobbledDeepslateWall, ObjectPhysicsData({ mass: 100000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.DeepslateBricksWall, ObjectPhysicsData({ mass: 100000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.SandstoneWall, ObjectPhysicsData({ mass: 30000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.RedSandstoneWall, ObjectPhysicsData({ mass: 37500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.BrickBlockWall, ObjectPhysicsData({ mass: 9600000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.MudBricksWall, ObjectPhysicsData({ mass: 5000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.TuffBricksWall, ObjectPhysicsData({ mass: 15000000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.OakFence, ObjectPhysicsData({ mass: 7500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.BirchFence, ObjectPhysicsData({ mass: 7500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.JungleFence, ObjectPhysicsData({ mass: 7500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.SakuraFence, ObjectPhysicsData({ mass: 7500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.AcaciaFence, ObjectPhysicsData({ mass: 7500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.SpruceFence, ObjectPhysicsData({ mass: 7500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.DarkOakFence, ObjectPhysicsData({ mass: 7500000000000000, energy: 0 })); + ObjectPhysics.set(ObjectTypes.MangroveFence, ObjectPhysicsData({ mass: 7500000000000000, energy: 0 })); ObjectPhysics.set(ObjectTypes.WoodenPick, ObjectPhysicsData({ mass: 22500000000000000, energy: 0 })); ObjectPhysics.set(ObjectTypes.CopperPick, ObjectPhysicsData({ mass: 534000000000000000, energy: 0 })); ObjectPhysics.set(ObjectTypes.IronPick, ObjectPhysicsData({ mass: 2034000000000000000, energy: 0 })); diff --git a/packages/world/script/initRecipes.sol b/packages/world/script/initRecipes.sol index f4bceb60..62ea26a5 100644 --- a/packages/world/script/initRecipes.sol +++ b/packages/world/script/initRecipes.sol @@ -3157,6 +3157,166 @@ function initRecipes() { outputAmounts ); } + { + uint16[] memory inputTypes = new uint16[](2); + uint16[] memory inputAmounts = new uint16[](2); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.OakPlanks.unwrap(), 4); + (inputTypes[1], inputAmounts[1]) = (ObjectTypes.Stick.unwrap(), 2); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.OakFence.unwrap(), 3); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Null, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Null, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](2); + uint16[] memory inputAmounts = new uint16[](2); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.BirchPlanks.unwrap(), 4); + (inputTypes[1], inputAmounts[1]) = (ObjectTypes.Stick.unwrap(), 2); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.BirchFence.unwrap(), 3); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Null, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Null, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](2); + uint16[] memory inputAmounts = new uint16[](2); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.JunglePlanks.unwrap(), 4); + (inputTypes[1], inputAmounts[1]) = (ObjectTypes.Stick.unwrap(), 2); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.JungleFence.unwrap(), 3); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Null, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Null, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](2); + uint16[] memory inputAmounts = new uint16[](2); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.SakuraPlanks.unwrap(), 4); + (inputTypes[1], inputAmounts[1]) = (ObjectTypes.Stick.unwrap(), 2); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.SakuraFence.unwrap(), 3); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Null, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Null, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](2); + uint16[] memory inputAmounts = new uint16[](2); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.AcaciaPlanks.unwrap(), 4); + (inputTypes[1], inputAmounts[1]) = (ObjectTypes.Stick.unwrap(), 2); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.AcaciaFence.unwrap(), 3); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Null, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Null, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](2); + uint16[] memory inputAmounts = new uint16[](2); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.SprucePlanks.unwrap(), 4); + (inputTypes[1], inputAmounts[1]) = (ObjectTypes.Stick.unwrap(), 2); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.SpruceFence.unwrap(), 3); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Null, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Null, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](2); + uint16[] memory inputAmounts = new uint16[](2); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.DarkOakPlanks.unwrap(), 4); + (inputTypes[1], inputAmounts[1]) = (ObjectTypes.Stick.unwrap(), 2); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.DarkOakFence.unwrap(), 3); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Null, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Null, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](2); + uint16[] memory inputAmounts = new uint16[](2); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.MangrovePlanks.unwrap(), 4); + (inputTypes[1], inputAmounts[1]) = (ObjectTypes.Stick.unwrap(), 2); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.MangroveFence.unwrap(), 3); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Null, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Null, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } { uint16[] memory inputTypes = new uint16[](2); uint16[] memory inputAmounts = new uint16[](2); @@ -3177,4 +3337,1790 @@ function initRecipes() { outputAmounts ); } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Stone.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.StoneStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Cobblestone.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.CobblestoneStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.MossyCobblestone.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.MossyCobblestoneStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.StoneBricks.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.StoneBricksStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.SmoothStone.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.SmoothStoneStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Andesite.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.AndesiteStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Granite.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.GraniteStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Diorite.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.DioriteStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Tuff.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.TuffStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Basalt.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.BasaltStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Blackstone.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.BlackstoneStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.PolishedAndesite.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.PolishedAndesiteStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.PolishedGranite.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.PolishedGraniteStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.PolishedDiorite.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.PolishedDioriteStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.PolishedTuff.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.PolishedTuffStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.PolishedBasalt.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.PolishedBasaltStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.PolishedBlackstone.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.PolishedBlackstoneStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Deepslate.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.DeepslateStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.CobbledDeepslate.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.CobbledDeepslateStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.DeepslateBricks.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.DeepslateBricksStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Sandstone.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.SandstoneStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.RedSandstone.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.RedSandstoneStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.SmoothSandstone.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.SmoothSandstoneStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.SmoothRedSandstone.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.SmoothRedSandstoneStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.BrickBlock.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.BrickBlockStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.MudBricks.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.MudBricksStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.TuffBricks.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.TuffBricksStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.OakPlanks.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.OakPlanksStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Null, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Null, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.BirchPlanks.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.BirchPlanksStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Null, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Null, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.JunglePlanks.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.JunglePlanksStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Null, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Null, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.SakuraPlanks.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.SakuraPlanksStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Null, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Null, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.AcaciaPlanks.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.AcaciaPlanksStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Null, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Null, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.SprucePlanks.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.SprucePlanksStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Null, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Null, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.DarkOakPlanks.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.DarkOakPlanksStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Null, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Null, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.MangrovePlanks.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.MangrovePlanksStairs.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Null, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Null, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Stone.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.StoneSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Cobblestone.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.CobblestoneSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.MossyCobblestone.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.MossyCobblestoneSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.StoneBricks.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.StoneBricksSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.SmoothStone.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.SmoothStoneSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Andesite.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.AndesiteSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Granite.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.GraniteSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Diorite.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.DioriteSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Tuff.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.TuffSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Basalt.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.BasaltSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Blackstone.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.BlackstoneSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.PolishedAndesite.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.PolishedAndesiteSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.PolishedGranite.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.PolishedGraniteSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.PolishedDiorite.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.PolishedDioriteSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.PolishedTuff.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.PolishedTuffSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.PolishedBasalt.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.PolishedBasaltSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.PolishedBlackstone.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.PolishedBlackstoneSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Deepslate.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.DeepslateSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.CobbledDeepslate.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.CobbledDeepslateSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.DeepslateBricks.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.DeepslateBricksSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Sandstone.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.SandstoneSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.RedSandstone.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.RedSandstoneSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.SmoothSandstone.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.SmoothSandstoneSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.SmoothRedSandstone.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.SmoothRedSandstoneSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.BrickBlock.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.BrickBlockSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.MudBricks.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.MudBricksSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.TuffBricks.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.TuffBricksSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.OakPlanks.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.OakPlanksSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Null, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Null, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.BirchPlanks.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.BirchPlanksSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Null, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Null, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.JunglePlanks.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.JunglePlanksSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Null, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Null, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.SakuraPlanks.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.SakuraPlanksSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Null, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Null, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.AcaciaPlanks.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.AcaciaPlanksSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Null, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Null, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.SprucePlanks.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.SprucePlanksSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Null, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Null, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.DarkOakPlanks.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.DarkOakPlanksSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Null, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Null, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.MangrovePlanks.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.MangrovePlanksSlab.unwrap(), 2); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Null, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Null, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Stone.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.StoneWall.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Cobblestone.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.CobblestoneWall.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.MossyCobblestone.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.MossyCobblestoneWall.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.StoneBricks.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.StoneBricksWall.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Andesite.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.AndesiteWall.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Granite.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.GraniteWall.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Diorite.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.DioriteWall.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Tuff.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.TuffWall.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Basalt.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.BasaltWall.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Blackstone.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.BlackstoneWall.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.PolishedAndesite.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.PolishedAndesiteWall.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.PolishedGranite.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.PolishedGraniteWall.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.PolishedDiorite.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.PolishedDioriteWall.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.PolishedTuff.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.PolishedTuffWall.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.PolishedBasalt.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.PolishedBasaltWall.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.PolishedBlackstone.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.PolishedBlackstoneWall.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Deepslate.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.DeepslateWall.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.CobbledDeepslate.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.CobbledDeepslateWall.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.DeepslateBricks.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.DeepslateBricksWall.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.Sandstone.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.SandstoneWall.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.RedSandstone.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.RedSandstoneWall.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.BrickBlock.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.BrickBlockWall.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.MudBricks.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.MudBricksWall.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } + { + uint16[] memory inputTypes = new uint16[](1); + uint16[] memory inputAmounts = new uint16[](1); + (inputTypes[0], inputAmounts[0]) = (ObjectTypes.TuffBricks.unwrap(), 1); + + uint16[] memory outputTypes = new uint16[](1); + uint16[] memory outputAmounts = new uint16[](1); + (outputTypes[0], outputAmounts[0]) = (ObjectTypes.TuffBricksWall.unwrap(), 1); + + Recipes.set( + keccak256(abi.encode(ObjectTypes.Stonecutter, inputTypes, inputAmounts, outputTypes, outputAmounts)), + ObjectTypes.Stonecutter, + 0, + inputTypes, + inputAmounts, + outputTypes, + outputAmounts + ); + } } diff --git a/packages/world/src/types/ObjectType.sol b/packages/world/src/types/ObjectType.sol index c22d5067..94c3f18f 100644 --- a/packages/world/src/types/ObjectType.sol +++ b/packages/world/src/types/ObjectType.sol @@ -3,7 +3,6 @@ pragma solidity >=0.8.24; import { IMachineSystem } from "../codegen/world/IMachineSystem.sol"; import { ITransferSystem } from "../codegen/world/ITransferSystem.sol"; - import { Orientation } from "./Orientation.sol"; import { Vec3, vec3 } from "./Vec3.sol"; @@ -267,6 +266,108 @@ library ObjectTypes { ObjectType constant Paper = ObjectType.wrap(387); ObjectType constant Stick = ObjectType.wrap(388); ObjectType constant Lodestone = ObjectType.wrap(389); + ObjectType constant StoneStairs = ObjectType.wrap(398); + ObjectType constant CobblestoneStairs = ObjectType.wrap(399); + ObjectType constant MossyCobblestoneStairs = ObjectType.wrap(400); + ObjectType constant StoneBricksStairs = ObjectType.wrap(401); + ObjectType constant SmoothStoneStairs = ObjectType.wrap(402); + ObjectType constant AndesiteStairs = ObjectType.wrap(403); + ObjectType constant GraniteStairs = ObjectType.wrap(404); + ObjectType constant DioriteStairs = ObjectType.wrap(405); + ObjectType constant TuffStairs = ObjectType.wrap(406); + ObjectType constant BasaltStairs = ObjectType.wrap(407); + ObjectType constant BlackstoneStairs = ObjectType.wrap(408); + ObjectType constant PolishedAndesiteStairs = ObjectType.wrap(409); + ObjectType constant PolishedGraniteStairs = ObjectType.wrap(410); + ObjectType constant PolishedDioriteStairs = ObjectType.wrap(411); + ObjectType constant PolishedTuffStairs = ObjectType.wrap(412); + ObjectType constant PolishedBasaltStairs = ObjectType.wrap(413); + ObjectType constant PolishedBlackstoneStairs = ObjectType.wrap(414); + ObjectType constant DeepslateStairs = ObjectType.wrap(415); + ObjectType constant CobbledDeepslateStairs = ObjectType.wrap(416); + ObjectType constant DeepslateBricksStairs = ObjectType.wrap(417); + ObjectType constant SandstoneStairs = ObjectType.wrap(418); + ObjectType constant RedSandstoneStairs = ObjectType.wrap(419); + ObjectType constant SmoothSandstoneStairs = ObjectType.wrap(420); + ObjectType constant SmoothRedSandstoneStairs = ObjectType.wrap(421); + ObjectType constant BrickBlockStairs = ObjectType.wrap(422); + ObjectType constant MudBricksStairs = ObjectType.wrap(423); + ObjectType constant TuffBricksStairs = ObjectType.wrap(424); + ObjectType constant OakPlanksStairs = ObjectType.wrap(425); + ObjectType constant BirchPlanksStairs = ObjectType.wrap(426); + ObjectType constant JunglePlanksStairs = ObjectType.wrap(427); + ObjectType constant SakuraPlanksStairs = ObjectType.wrap(428); + ObjectType constant AcaciaPlanksStairs = ObjectType.wrap(429); + ObjectType constant SprucePlanksStairs = ObjectType.wrap(430); + ObjectType constant DarkOakPlanksStairs = ObjectType.wrap(431); + ObjectType constant MangrovePlanksStairs = ObjectType.wrap(432); + ObjectType constant StoneSlab = ObjectType.wrap(433); + ObjectType constant CobblestoneSlab = ObjectType.wrap(434); + ObjectType constant MossyCobblestoneSlab = ObjectType.wrap(435); + ObjectType constant StoneBricksSlab = ObjectType.wrap(436); + ObjectType constant SmoothStoneSlab = ObjectType.wrap(437); + ObjectType constant AndesiteSlab = ObjectType.wrap(438); + ObjectType constant GraniteSlab = ObjectType.wrap(439); + ObjectType constant DioriteSlab = ObjectType.wrap(440); + ObjectType constant TuffSlab = ObjectType.wrap(441); + ObjectType constant BasaltSlab = ObjectType.wrap(442); + ObjectType constant BlackstoneSlab = ObjectType.wrap(443); + ObjectType constant PolishedAndesiteSlab = ObjectType.wrap(444); + ObjectType constant PolishedGraniteSlab = ObjectType.wrap(445); + ObjectType constant PolishedDioriteSlab = ObjectType.wrap(446); + ObjectType constant PolishedTuffSlab = ObjectType.wrap(447); + ObjectType constant PolishedBasaltSlab = ObjectType.wrap(448); + ObjectType constant PolishedBlackstoneSlab = ObjectType.wrap(449); + ObjectType constant DeepslateSlab = ObjectType.wrap(450); + ObjectType constant CobbledDeepslateSlab = ObjectType.wrap(451); + ObjectType constant DeepslateBricksSlab = ObjectType.wrap(452); + ObjectType constant SandstoneSlab = ObjectType.wrap(453); + ObjectType constant RedSandstoneSlab = ObjectType.wrap(454); + ObjectType constant SmoothSandstoneSlab = ObjectType.wrap(455); + ObjectType constant SmoothRedSandstoneSlab = ObjectType.wrap(456); + ObjectType constant BrickBlockSlab = ObjectType.wrap(457); + ObjectType constant MudBricksSlab = ObjectType.wrap(458); + ObjectType constant TuffBricksSlab = ObjectType.wrap(459); + ObjectType constant OakPlanksSlab = ObjectType.wrap(460); + ObjectType constant BirchPlanksSlab = ObjectType.wrap(461); + ObjectType constant JunglePlanksSlab = ObjectType.wrap(462); + ObjectType constant SakuraPlanksSlab = ObjectType.wrap(463); + ObjectType constant AcaciaPlanksSlab = ObjectType.wrap(464); + ObjectType constant SprucePlanksSlab = ObjectType.wrap(465); + ObjectType constant DarkOakPlanksSlab = ObjectType.wrap(466); + ObjectType constant MangrovePlanksSlab = ObjectType.wrap(467); + ObjectType constant StoneWall = ObjectType.wrap(468); + ObjectType constant CobblestoneWall = ObjectType.wrap(469); + ObjectType constant MossyCobblestoneWall = ObjectType.wrap(470); + ObjectType constant StoneBricksWall = ObjectType.wrap(471); + ObjectType constant AndesiteWall = ObjectType.wrap(472); + ObjectType constant GraniteWall = ObjectType.wrap(473); + ObjectType constant DioriteWall = ObjectType.wrap(474); + ObjectType constant TuffWall = ObjectType.wrap(475); + ObjectType constant BasaltWall = ObjectType.wrap(476); + ObjectType constant BlackstoneWall = ObjectType.wrap(477); + ObjectType constant PolishedAndesiteWall = ObjectType.wrap(478); + ObjectType constant PolishedGraniteWall = ObjectType.wrap(479); + ObjectType constant PolishedDioriteWall = ObjectType.wrap(480); + ObjectType constant PolishedTuffWall = ObjectType.wrap(481); + ObjectType constant PolishedBasaltWall = ObjectType.wrap(482); + ObjectType constant PolishedBlackstoneWall = ObjectType.wrap(483); + ObjectType constant DeepslateWall = ObjectType.wrap(484); + ObjectType constant CobbledDeepslateWall = ObjectType.wrap(485); + ObjectType constant DeepslateBricksWall = ObjectType.wrap(486); + ObjectType constant SandstoneWall = ObjectType.wrap(487); + ObjectType constant RedSandstoneWall = ObjectType.wrap(488); + ObjectType constant BrickBlockWall = ObjectType.wrap(489); + ObjectType constant MudBricksWall = ObjectType.wrap(490); + ObjectType constant TuffBricksWall = ObjectType.wrap(491); + ObjectType constant OakFence = ObjectType.wrap(510); + ObjectType constant BirchFence = ObjectType.wrap(511); + ObjectType constant JungleFence = ObjectType.wrap(512); + ObjectType constant SakuraFence = ObjectType.wrap(513); + ObjectType constant AcaciaFence = ObjectType.wrap(514); + ObjectType constant SpruceFence = ObjectType.wrap(515); + ObjectType constant DarkOakFence = ObjectType.wrap(516); + ObjectType constant MangroveFence = ObjectType.wrap(517); ObjectType constant WoodenPick = ObjectType.wrap(32768); ObjectType constant CopperPick = ObjectType.wrap(32769); ObjectType constant IronPick = ObjectType.wrap(32770); @@ -349,7 +450,14 @@ library ObjectTypeLib { // IDs in [256..511] { let off := sub(self, 256) - let bit := and(shr(off, 0x26ffffffff00007629c00000000ffdffff), 1) + let bit := and(shr(off, 0xc0000fffffffffffffffffffffffc026ffffffff00007629c00000000ffdffff), 1) + ok := or(ok, bit) + } + + // IDs in [512..767] + { + let off := sub(self, 512) + let bit := and(shr(off, 0x3f), 1) ok := or(ok, bit) } } @@ -755,7 +863,7 @@ library ObjectTypeLib { return [ObjectTypes.AnyPlank, ObjectTypes.AnyLog, ObjectTypes.AnyLeaf, ObjectTypes.AnyTerracotta]; } - function getBlockTypes() internal pure returns (ObjectType[224] memory) { + function getBlockTypes() internal pure returns (ObjectType[326] memory) { return [ ObjectTypes.Stone, ObjectTypes.Deepslate, @@ -980,7 +1088,109 @@ library ObjectTypeLib { ObjectTypes.BrownConcrete, ObjectTypes.GreenConcrete, ObjectTypes.RedConcrete, - ObjectTypes.BlackConcrete + ObjectTypes.BlackConcrete, + ObjectTypes.StoneStairs, + ObjectTypes.CobblestoneStairs, + ObjectTypes.MossyCobblestoneStairs, + ObjectTypes.StoneBricksStairs, + ObjectTypes.SmoothStoneStairs, + ObjectTypes.AndesiteStairs, + ObjectTypes.GraniteStairs, + ObjectTypes.DioriteStairs, + ObjectTypes.TuffStairs, + ObjectTypes.BasaltStairs, + ObjectTypes.BlackstoneStairs, + ObjectTypes.PolishedAndesiteStairs, + ObjectTypes.PolishedGraniteStairs, + ObjectTypes.PolishedDioriteStairs, + ObjectTypes.PolishedTuffStairs, + ObjectTypes.PolishedBasaltStairs, + ObjectTypes.PolishedBlackstoneStairs, + ObjectTypes.DeepslateStairs, + ObjectTypes.CobbledDeepslateStairs, + ObjectTypes.DeepslateBricksStairs, + ObjectTypes.SandstoneStairs, + ObjectTypes.RedSandstoneStairs, + ObjectTypes.SmoothSandstoneStairs, + ObjectTypes.SmoothRedSandstoneStairs, + ObjectTypes.BrickBlockStairs, + ObjectTypes.MudBricksStairs, + ObjectTypes.TuffBricksStairs, + ObjectTypes.OakPlanksStairs, + ObjectTypes.BirchPlanksStairs, + ObjectTypes.JunglePlanksStairs, + ObjectTypes.SakuraPlanksStairs, + ObjectTypes.AcaciaPlanksStairs, + ObjectTypes.SprucePlanksStairs, + ObjectTypes.DarkOakPlanksStairs, + ObjectTypes.MangrovePlanksStairs, + ObjectTypes.StoneSlab, + ObjectTypes.CobblestoneSlab, + ObjectTypes.MossyCobblestoneSlab, + ObjectTypes.StoneBricksSlab, + ObjectTypes.SmoothStoneSlab, + ObjectTypes.AndesiteSlab, + ObjectTypes.GraniteSlab, + ObjectTypes.DioriteSlab, + ObjectTypes.TuffSlab, + ObjectTypes.BasaltSlab, + ObjectTypes.BlackstoneSlab, + ObjectTypes.PolishedAndesiteSlab, + ObjectTypes.PolishedGraniteSlab, + ObjectTypes.PolishedDioriteSlab, + ObjectTypes.PolishedTuffSlab, + ObjectTypes.PolishedBasaltSlab, + ObjectTypes.PolishedBlackstoneSlab, + ObjectTypes.DeepslateSlab, + ObjectTypes.CobbledDeepslateSlab, + ObjectTypes.DeepslateBricksSlab, + ObjectTypes.SandstoneSlab, + ObjectTypes.RedSandstoneSlab, + ObjectTypes.SmoothSandstoneSlab, + ObjectTypes.SmoothRedSandstoneSlab, + ObjectTypes.BrickBlockSlab, + ObjectTypes.MudBricksSlab, + ObjectTypes.TuffBricksSlab, + ObjectTypes.OakPlanksSlab, + ObjectTypes.BirchPlanksSlab, + ObjectTypes.JunglePlanksSlab, + ObjectTypes.SakuraPlanksSlab, + ObjectTypes.AcaciaPlanksSlab, + ObjectTypes.SprucePlanksSlab, + ObjectTypes.DarkOakPlanksSlab, + ObjectTypes.MangrovePlanksSlab, + ObjectTypes.StoneWall, + ObjectTypes.CobblestoneWall, + ObjectTypes.MossyCobblestoneWall, + ObjectTypes.StoneBricksWall, + ObjectTypes.AndesiteWall, + ObjectTypes.GraniteWall, + ObjectTypes.DioriteWall, + ObjectTypes.TuffWall, + ObjectTypes.BasaltWall, + ObjectTypes.BlackstoneWall, + ObjectTypes.PolishedAndesiteWall, + ObjectTypes.PolishedGraniteWall, + ObjectTypes.PolishedDioriteWall, + ObjectTypes.PolishedTuffWall, + ObjectTypes.PolishedBasaltWall, + ObjectTypes.PolishedBlackstoneWall, + ObjectTypes.DeepslateWall, + ObjectTypes.CobbledDeepslateWall, + ObjectTypes.DeepslateBricksWall, + ObjectTypes.SandstoneWall, + ObjectTypes.RedSandstoneWall, + ObjectTypes.BrickBlockWall, + ObjectTypes.MudBricksWall, + ObjectTypes.TuffBricksWall, + ObjectTypes.OakFence, + ObjectTypes.BirchFence, + ObjectTypes.JungleFence, + ObjectTypes.SakuraFence, + ObjectTypes.AcaciaFence, + ObjectTypes.SpruceFence, + ObjectTypes.DarkOakFence, + ObjectTypes.MangroveFence ]; } @@ -1739,43 +1949,33 @@ library ObjectTypeLib { } function isOrientationSupported(ObjectType self, Orientation orientation) internal pure returns (bool) { - if (self == ObjectTypes.TextSign) { - return orientation == Orientation.wrap(0) || orientation == Orientation.wrap(1) - || orientation == Orientation.wrap(40) || orientation == Orientation.wrap(44); - } - if (self == ObjectTypes.ForceField) { - return orientation == Orientation.wrap(0) || orientation == Orientation.wrap(1) - || orientation == Orientation.wrap(40) || orientation == Orientation.wrap(44); - } - if (self == ObjectTypes.Chest) { - return orientation == Orientation.wrap(0) || orientation == Orientation.wrap(1) - || orientation == Orientation.wrap(40) || orientation == Orientation.wrap(44); - } - if (self == ObjectTypes.SpawnTile) { - return orientation == Orientation.wrap(0) || orientation == Orientation.wrap(1) - || orientation == Orientation.wrap(40) || orientation == Orientation.wrap(44); - } - if (self == ObjectTypes.Bed) { - return orientation == Orientation.wrap(1) || orientation == Orientation.wrap(44); - } - if (self == ObjectTypes.Workbench) { - return orientation == Orientation.wrap(0) || orientation == Orientation.wrap(1) - || orientation == Orientation.wrap(40) || orientation == Orientation.wrap(44); + uint8 orientationValue = Orientation.unwrap(orientation); + + // Check if orientation is valid (0-47) + if (orientationValue >= 48) return false; + + uint64 orientationBit = uint64(1) << orientationValue; + uint16 selfId = self.unwrap(); + + // Orientations [0, 1, 40, 44]: TextSign, ForceField, Chest... + if (selfId == 120 || (selfId >= 145 && selfId <= 147) || (selfId >= 149 && selfId <= 151) || selfId == 256) { + return (orientationBit & 0x110000000003) != 0; } - if (self == ObjectTypes.Powerstone) { - return orientation == Orientation.wrap(0) || orientation == Orientation.wrap(1) - || orientation == Orientation.wrap(40) || orientation == Orientation.wrap(44); + // Orientations [1, 44]: Bed + if (selfId == 148) { + return (orientationBit & 0x100000000002) != 0; } - if (self == ObjectTypes.Furnace) { - return orientation == Orientation.wrap(0) || orientation == Orientation.wrap(1) - || orientation == Orientation.wrap(40) || orientation == Orientation.wrap(44); + // Orientations [0, 1, 2, 3, 40, 41, 42, 43]: StoneStairs, CobblestoneStairs, MossyCobblestoneStairs... + if ((selfId >= 398 && selfId <= 432)) { + return (orientationBit & 0xf000000000f) != 0; } - if (self == ObjectTypes.Stonecutter) { - return orientation == Orientation.wrap(0) || orientation == Orientation.wrap(1) - || orientation == Orientation.wrap(40) || orientation == Orientation.wrap(44); + // Orientations [0, 2]: StoneSlab, CobblestoneSlab, MossyCobblestoneSlab... + if ((selfId >= 433 && selfId <= 467)) { + return (orientationBit & 0x5) != 0; } - return orientation == Orientation.wrap(0); + // Default: only orientation 0 is supported + return orientationValue == 0; } function getRelativeCoords(ObjectType self, Vec3 baseCoord) internal pure returns (Vec3[] memory) { diff --git a/packages/world/test/ObjectType.t.sol b/packages/world/test/ObjectType.t.sol index c2a6f1c8..be9bdc53 100644 --- a/packages/world/test/ObjectType.t.sol +++ b/packages/world/test/ObjectType.t.sol @@ -256,6 +256,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.isNonSolid(), "!isNonSolid"); assertFalse(ObjectTypes.Stick.isNonSolid(), "!isNonSolid"); assertFalse(ObjectTypes.Lodestone.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.StoneStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.CobblestoneStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.StoneBricksStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.SmoothStoneStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.AndesiteStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.GraniteStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.DioriteStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.TuffStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.BasaltStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.BlackstoneStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.PolishedTuffStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.DeepslateStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.SandstoneStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.RedSandstoneStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.BrickBlockStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.MudBricksStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.TuffBricksStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.OakPlanksStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.BirchPlanksStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.JunglePlanksStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.SprucePlanksStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.StoneSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.CobblestoneSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.StoneBricksSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.SmoothStoneSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.AndesiteSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.GraniteSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.DioriteSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.TuffSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.BasaltSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.BlackstoneSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.PolishedTuffSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.DeepslateSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.SandstoneSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.RedSandstoneSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.BrickBlockSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.MudBricksSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.TuffBricksSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.OakPlanksSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.BirchPlanksSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.JunglePlanksSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.SprucePlanksSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.StoneWall.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.CobblestoneWall.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.StoneBricksWall.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.AndesiteWall.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.GraniteWall.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.DioriteWall.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.TuffWall.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.BasaltWall.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.BlackstoneWall.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.PolishedGraniteWall.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.PolishedDioriteWall.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.PolishedTuffWall.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.PolishedBasaltWall.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.DeepslateWall.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.DeepslateBricksWall.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.SandstoneWall.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.RedSandstoneWall.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.BrickBlockWall.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.MudBricksWall.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.TuffBricksWall.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.OakFence.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.BirchFence.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.JungleFence.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.SakuraFence.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.AcaciaFence.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.SpruceFence.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.DarkOakFence.isNonSolid(), "!isNonSolid"); + assertFalse(ObjectTypes.MangroveFence.isNonSolid(), "!isNonSolid"); assertFalse(ObjectTypes.WoodenPick.isNonSolid(), "!isNonSolid"); assertFalse(ObjectTypes.CopperPick.isNonSolid(), "!isNonSolid"); assertFalse(ObjectTypes.IronPick.isNonSolid(), "!isNonSolid"); @@ -543,6 +645,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.isAny(), "!isAny"); assertFalse(ObjectTypes.Stick.isAny(), "!isAny"); assertFalse(ObjectTypes.Lodestone.isAny(), "!isAny"); + assertFalse(ObjectTypes.StoneStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.CobblestoneStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.StoneBricksStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.SmoothStoneStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.AndesiteStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.GraniteStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.DioriteStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.TuffStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.BasaltStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.BlackstoneStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.PolishedTuffStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.DeepslateStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.SandstoneStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.RedSandstoneStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.BrickBlockStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.MudBricksStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.TuffBricksStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.OakPlanksStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.BirchPlanksStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.JunglePlanksStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.SprucePlanksStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isAny(), "!isAny"); + assertFalse(ObjectTypes.StoneSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.CobblestoneSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.StoneBricksSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.SmoothStoneSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.AndesiteSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.GraniteSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.DioriteSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.TuffSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.BasaltSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.BlackstoneSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.PolishedTuffSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.DeepslateSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.SandstoneSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.RedSandstoneSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.BrickBlockSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.MudBricksSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.TuffBricksSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.OakPlanksSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.BirchPlanksSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.JunglePlanksSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.SprucePlanksSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isAny(), "!isAny"); + assertFalse(ObjectTypes.StoneWall.isAny(), "!isAny"); + assertFalse(ObjectTypes.CobblestoneWall.isAny(), "!isAny"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isAny(), "!isAny"); + assertFalse(ObjectTypes.StoneBricksWall.isAny(), "!isAny"); + assertFalse(ObjectTypes.AndesiteWall.isAny(), "!isAny"); + assertFalse(ObjectTypes.GraniteWall.isAny(), "!isAny"); + assertFalse(ObjectTypes.DioriteWall.isAny(), "!isAny"); + assertFalse(ObjectTypes.TuffWall.isAny(), "!isAny"); + assertFalse(ObjectTypes.BasaltWall.isAny(), "!isAny"); + assertFalse(ObjectTypes.BlackstoneWall.isAny(), "!isAny"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isAny(), "!isAny"); + assertFalse(ObjectTypes.PolishedGraniteWall.isAny(), "!isAny"); + assertFalse(ObjectTypes.PolishedDioriteWall.isAny(), "!isAny"); + assertFalse(ObjectTypes.PolishedTuffWall.isAny(), "!isAny"); + assertFalse(ObjectTypes.PolishedBasaltWall.isAny(), "!isAny"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isAny(), "!isAny"); + assertFalse(ObjectTypes.DeepslateWall.isAny(), "!isAny"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isAny(), "!isAny"); + assertFalse(ObjectTypes.DeepslateBricksWall.isAny(), "!isAny"); + assertFalse(ObjectTypes.SandstoneWall.isAny(), "!isAny"); + assertFalse(ObjectTypes.RedSandstoneWall.isAny(), "!isAny"); + assertFalse(ObjectTypes.BrickBlockWall.isAny(), "!isAny"); + assertFalse(ObjectTypes.MudBricksWall.isAny(), "!isAny"); + assertFalse(ObjectTypes.TuffBricksWall.isAny(), "!isAny"); + assertFalse(ObjectTypes.OakFence.isAny(), "!isAny"); + assertFalse(ObjectTypes.BirchFence.isAny(), "!isAny"); + assertFalse(ObjectTypes.JungleFence.isAny(), "!isAny"); + assertFalse(ObjectTypes.SakuraFence.isAny(), "!isAny"); + assertFalse(ObjectTypes.AcaciaFence.isAny(), "!isAny"); + assertFalse(ObjectTypes.SpruceFence.isAny(), "!isAny"); + assertFalse(ObjectTypes.DarkOakFence.isAny(), "!isAny"); + assertFalse(ObjectTypes.MangroveFence.isAny(), "!isAny"); assertFalse(ObjectTypes.WoodenPick.isAny(), "!isAny"); assertFalse(ObjectTypes.CopperPick.isAny(), "!isAny"); assertFalse(ObjectTypes.IronPick.isAny(), "!isAny"); @@ -798,6 +1002,108 @@ contract ObjectTypeTest is DustTest { assertTrue(ObjectTypes.GreenConcrete.isBlock(), "isBlock"); assertTrue(ObjectTypes.RedConcrete.isBlock(), "isBlock"); assertTrue(ObjectTypes.BlackConcrete.isBlock(), "isBlock"); + assertTrue(ObjectTypes.StoneStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.CobblestoneStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.MossyCobblestoneStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.StoneBricksStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.SmoothStoneStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.AndesiteStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.GraniteStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.DioriteStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.TuffStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.BasaltStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.BlackstoneStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.PolishedAndesiteStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.PolishedGraniteStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.PolishedDioriteStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.PolishedTuffStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.PolishedBasaltStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.PolishedBlackstoneStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.DeepslateStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.CobbledDeepslateStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.DeepslateBricksStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.SandstoneStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.RedSandstoneStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.SmoothSandstoneStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.SmoothRedSandstoneStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.BrickBlockStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.MudBricksStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.TuffBricksStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.OakPlanksStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.BirchPlanksStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.JunglePlanksStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.SakuraPlanksStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.AcaciaPlanksStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.SprucePlanksStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.DarkOakPlanksStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.MangrovePlanksStairs.isBlock(), "isBlock"); + assertTrue(ObjectTypes.StoneSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.CobblestoneSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.MossyCobblestoneSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.StoneBricksSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.SmoothStoneSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.AndesiteSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.GraniteSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.DioriteSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.TuffSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.BasaltSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.BlackstoneSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.PolishedAndesiteSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.PolishedGraniteSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.PolishedDioriteSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.PolishedTuffSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.PolishedBasaltSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.PolishedBlackstoneSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.DeepslateSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.CobbledDeepslateSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.DeepslateBricksSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.SandstoneSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.RedSandstoneSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.SmoothSandstoneSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.SmoothRedSandstoneSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.BrickBlockSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.MudBricksSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.TuffBricksSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.OakPlanksSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.BirchPlanksSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.JunglePlanksSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.SakuraPlanksSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.AcaciaPlanksSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.SprucePlanksSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.DarkOakPlanksSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.MangrovePlanksSlab.isBlock(), "isBlock"); + assertTrue(ObjectTypes.StoneWall.isBlock(), "isBlock"); + assertTrue(ObjectTypes.CobblestoneWall.isBlock(), "isBlock"); + assertTrue(ObjectTypes.MossyCobblestoneWall.isBlock(), "isBlock"); + assertTrue(ObjectTypes.StoneBricksWall.isBlock(), "isBlock"); + assertTrue(ObjectTypes.AndesiteWall.isBlock(), "isBlock"); + assertTrue(ObjectTypes.GraniteWall.isBlock(), "isBlock"); + assertTrue(ObjectTypes.DioriteWall.isBlock(), "isBlock"); + assertTrue(ObjectTypes.TuffWall.isBlock(), "isBlock"); + assertTrue(ObjectTypes.BasaltWall.isBlock(), "isBlock"); + assertTrue(ObjectTypes.BlackstoneWall.isBlock(), "isBlock"); + assertTrue(ObjectTypes.PolishedAndesiteWall.isBlock(), "isBlock"); + assertTrue(ObjectTypes.PolishedGraniteWall.isBlock(), "isBlock"); + assertTrue(ObjectTypes.PolishedDioriteWall.isBlock(), "isBlock"); + assertTrue(ObjectTypes.PolishedTuffWall.isBlock(), "isBlock"); + assertTrue(ObjectTypes.PolishedBasaltWall.isBlock(), "isBlock"); + assertTrue(ObjectTypes.PolishedBlackstoneWall.isBlock(), "isBlock"); + assertTrue(ObjectTypes.DeepslateWall.isBlock(), "isBlock"); + assertTrue(ObjectTypes.CobbledDeepslateWall.isBlock(), "isBlock"); + assertTrue(ObjectTypes.DeepslateBricksWall.isBlock(), "isBlock"); + assertTrue(ObjectTypes.SandstoneWall.isBlock(), "isBlock"); + assertTrue(ObjectTypes.RedSandstoneWall.isBlock(), "isBlock"); + assertTrue(ObjectTypes.BrickBlockWall.isBlock(), "isBlock"); + assertTrue(ObjectTypes.MudBricksWall.isBlock(), "isBlock"); + assertTrue(ObjectTypes.TuffBricksWall.isBlock(), "isBlock"); + assertTrue(ObjectTypes.OakFence.isBlock(), "isBlock"); + assertTrue(ObjectTypes.BirchFence.isBlock(), "isBlock"); + assertTrue(ObjectTypes.JungleFence.isBlock(), "isBlock"); + assertTrue(ObjectTypes.SakuraFence.isBlock(), "isBlock"); + assertTrue(ObjectTypes.AcaciaFence.isBlock(), "isBlock"); + assertTrue(ObjectTypes.SpruceFence.isBlock(), "isBlock"); + assertTrue(ObjectTypes.DarkOakFence.isBlock(), "isBlock"); + assertTrue(ObjectTypes.MangroveFence.isBlock(), "isBlock"); assertFalse(ObjectTypes.Null.isBlock(), "!isBlock"); assertFalse(ObjectTypes.Air.isBlock(), "!isBlock"); assertFalse(ObjectTypes.Water.isBlock(), "!isBlock"); @@ -1105,6 +1411,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.isTerracotta(), "!isTerracotta"); assertFalse(ObjectTypes.Stick.isTerracotta(), "!isTerracotta"); assertFalse(ObjectTypes.Lodestone.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.StoneStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.CobblestoneStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.StoneBricksStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.SmoothStoneStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.AndesiteStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.GraniteStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.DioriteStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.TuffStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.BasaltStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.BlackstoneStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.PolishedTuffStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.DeepslateStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.SandstoneStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.RedSandstoneStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.BrickBlockStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.MudBricksStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.TuffBricksStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.OakPlanksStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.BirchPlanksStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.JunglePlanksStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.SprucePlanksStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.StoneSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.CobblestoneSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.StoneBricksSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.SmoothStoneSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.AndesiteSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.GraniteSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.DioriteSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.TuffSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.BasaltSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.BlackstoneSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.PolishedTuffSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.DeepslateSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.SandstoneSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.RedSandstoneSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.BrickBlockSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.MudBricksSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.TuffBricksSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.OakPlanksSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.BirchPlanksSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.JunglePlanksSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.SprucePlanksSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.StoneWall.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.CobblestoneWall.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.StoneBricksWall.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.AndesiteWall.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.GraniteWall.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.DioriteWall.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.TuffWall.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.BasaltWall.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.BlackstoneWall.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.PolishedGraniteWall.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.PolishedDioriteWall.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.PolishedTuffWall.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.PolishedBasaltWall.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.DeepslateWall.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.DeepslateBricksWall.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.SandstoneWall.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.RedSandstoneWall.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.BrickBlockWall.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.MudBricksWall.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.TuffBricksWall.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.OakFence.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.BirchFence.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.JungleFence.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.SakuraFence.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.AcaciaFence.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.SpruceFence.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.DarkOakFence.isTerracotta(), "!isTerracotta"); + assertFalse(ObjectTypes.MangroveFence.isTerracotta(), "!isTerracotta"); assertFalse(ObjectTypes.WoodenPick.isTerracotta(), "!isTerracotta"); assertFalse(ObjectTypes.CopperPick.isTerracotta(), "!isTerracotta"); assertFalse(ObjectTypes.IronPick.isTerracotta(), "!isTerracotta"); @@ -1388,6 +1796,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.isOre(), "!isOre"); assertFalse(ObjectTypes.Stick.isOre(), "!isOre"); assertFalse(ObjectTypes.Lodestone.isOre(), "!isOre"); + assertFalse(ObjectTypes.StoneStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.CobblestoneStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.StoneBricksStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.SmoothStoneStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.AndesiteStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.GraniteStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.DioriteStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.TuffStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.BasaltStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.BlackstoneStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.PolishedTuffStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.DeepslateStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.SandstoneStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.RedSandstoneStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.BrickBlockStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.MudBricksStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.TuffBricksStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.OakPlanksStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.BirchPlanksStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.JunglePlanksStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.SprucePlanksStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isOre(), "!isOre"); + assertFalse(ObjectTypes.StoneSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.CobblestoneSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.StoneBricksSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.SmoothStoneSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.AndesiteSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.GraniteSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.DioriteSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.TuffSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.BasaltSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.BlackstoneSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.PolishedTuffSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.DeepslateSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.SandstoneSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.RedSandstoneSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.BrickBlockSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.MudBricksSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.TuffBricksSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.OakPlanksSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.BirchPlanksSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.JunglePlanksSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.SprucePlanksSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isOre(), "!isOre"); + assertFalse(ObjectTypes.StoneWall.isOre(), "!isOre"); + assertFalse(ObjectTypes.CobblestoneWall.isOre(), "!isOre"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isOre(), "!isOre"); + assertFalse(ObjectTypes.StoneBricksWall.isOre(), "!isOre"); + assertFalse(ObjectTypes.AndesiteWall.isOre(), "!isOre"); + assertFalse(ObjectTypes.GraniteWall.isOre(), "!isOre"); + assertFalse(ObjectTypes.DioriteWall.isOre(), "!isOre"); + assertFalse(ObjectTypes.TuffWall.isOre(), "!isOre"); + assertFalse(ObjectTypes.BasaltWall.isOre(), "!isOre"); + assertFalse(ObjectTypes.BlackstoneWall.isOre(), "!isOre"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isOre(), "!isOre"); + assertFalse(ObjectTypes.PolishedGraniteWall.isOre(), "!isOre"); + assertFalse(ObjectTypes.PolishedDioriteWall.isOre(), "!isOre"); + assertFalse(ObjectTypes.PolishedTuffWall.isOre(), "!isOre"); + assertFalse(ObjectTypes.PolishedBasaltWall.isOre(), "!isOre"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isOre(), "!isOre"); + assertFalse(ObjectTypes.DeepslateWall.isOre(), "!isOre"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isOre(), "!isOre"); + assertFalse(ObjectTypes.DeepslateBricksWall.isOre(), "!isOre"); + assertFalse(ObjectTypes.SandstoneWall.isOre(), "!isOre"); + assertFalse(ObjectTypes.RedSandstoneWall.isOre(), "!isOre"); + assertFalse(ObjectTypes.BrickBlockWall.isOre(), "!isOre"); + assertFalse(ObjectTypes.MudBricksWall.isOre(), "!isOre"); + assertFalse(ObjectTypes.TuffBricksWall.isOre(), "!isOre"); + assertFalse(ObjectTypes.OakFence.isOre(), "!isOre"); + assertFalse(ObjectTypes.BirchFence.isOre(), "!isOre"); + assertFalse(ObjectTypes.JungleFence.isOre(), "!isOre"); + assertFalse(ObjectTypes.SakuraFence.isOre(), "!isOre"); + assertFalse(ObjectTypes.AcaciaFence.isOre(), "!isOre"); + assertFalse(ObjectTypes.SpruceFence.isOre(), "!isOre"); + assertFalse(ObjectTypes.DarkOakFence.isOre(), "!isOre"); + assertFalse(ObjectTypes.MangroveFence.isOre(), "!isOre"); assertFalse(ObjectTypes.WoodenPick.isOre(), "!isOre"); assertFalse(ObjectTypes.CopperPick.isOre(), "!isOre"); assertFalse(ObjectTypes.IronPick.isOre(), "!isOre"); @@ -1671,6 +2181,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.isLog(), "!isLog"); assertFalse(ObjectTypes.Stick.isLog(), "!isLog"); assertFalse(ObjectTypes.Lodestone.isLog(), "!isLog"); + assertFalse(ObjectTypes.StoneStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.CobblestoneStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.StoneBricksStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.SmoothStoneStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.AndesiteStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.GraniteStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.DioriteStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.TuffStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.BasaltStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.BlackstoneStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.PolishedTuffStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.DeepslateStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.SandstoneStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.RedSandstoneStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.BrickBlockStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.MudBricksStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.TuffBricksStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.OakPlanksStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.BirchPlanksStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.JunglePlanksStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.SprucePlanksStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isLog(), "!isLog"); + assertFalse(ObjectTypes.StoneSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.CobblestoneSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.StoneBricksSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.SmoothStoneSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.AndesiteSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.GraniteSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.DioriteSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.TuffSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.BasaltSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.BlackstoneSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.PolishedTuffSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.DeepslateSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.SandstoneSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.RedSandstoneSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.BrickBlockSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.MudBricksSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.TuffBricksSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.OakPlanksSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.BirchPlanksSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.JunglePlanksSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.SprucePlanksSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isLog(), "!isLog"); + assertFalse(ObjectTypes.StoneWall.isLog(), "!isLog"); + assertFalse(ObjectTypes.CobblestoneWall.isLog(), "!isLog"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isLog(), "!isLog"); + assertFalse(ObjectTypes.StoneBricksWall.isLog(), "!isLog"); + assertFalse(ObjectTypes.AndesiteWall.isLog(), "!isLog"); + assertFalse(ObjectTypes.GraniteWall.isLog(), "!isLog"); + assertFalse(ObjectTypes.DioriteWall.isLog(), "!isLog"); + assertFalse(ObjectTypes.TuffWall.isLog(), "!isLog"); + assertFalse(ObjectTypes.BasaltWall.isLog(), "!isLog"); + assertFalse(ObjectTypes.BlackstoneWall.isLog(), "!isLog"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isLog(), "!isLog"); + assertFalse(ObjectTypes.PolishedGraniteWall.isLog(), "!isLog"); + assertFalse(ObjectTypes.PolishedDioriteWall.isLog(), "!isLog"); + assertFalse(ObjectTypes.PolishedTuffWall.isLog(), "!isLog"); + assertFalse(ObjectTypes.PolishedBasaltWall.isLog(), "!isLog"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isLog(), "!isLog"); + assertFalse(ObjectTypes.DeepslateWall.isLog(), "!isLog"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isLog(), "!isLog"); + assertFalse(ObjectTypes.DeepslateBricksWall.isLog(), "!isLog"); + assertFalse(ObjectTypes.SandstoneWall.isLog(), "!isLog"); + assertFalse(ObjectTypes.RedSandstoneWall.isLog(), "!isLog"); + assertFalse(ObjectTypes.BrickBlockWall.isLog(), "!isLog"); + assertFalse(ObjectTypes.MudBricksWall.isLog(), "!isLog"); + assertFalse(ObjectTypes.TuffBricksWall.isLog(), "!isLog"); + assertFalse(ObjectTypes.OakFence.isLog(), "!isLog"); + assertFalse(ObjectTypes.BirchFence.isLog(), "!isLog"); + assertFalse(ObjectTypes.JungleFence.isLog(), "!isLog"); + assertFalse(ObjectTypes.SakuraFence.isLog(), "!isLog"); + assertFalse(ObjectTypes.AcaciaFence.isLog(), "!isLog"); + assertFalse(ObjectTypes.SpruceFence.isLog(), "!isLog"); + assertFalse(ObjectTypes.DarkOakFence.isLog(), "!isLog"); + assertFalse(ObjectTypes.MangroveFence.isLog(), "!isLog"); assertFalse(ObjectTypes.WoodenPick.isLog(), "!isLog"); assertFalse(ObjectTypes.CopperPick.isLog(), "!isLog"); assertFalse(ObjectTypes.IronPick.isLog(), "!isLog"); @@ -1954,6 +2566,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.isLeaf(), "!isLeaf"); assertFalse(ObjectTypes.Stick.isLeaf(), "!isLeaf"); assertFalse(ObjectTypes.Lodestone.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.StoneStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.CobblestoneStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.StoneBricksStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.SmoothStoneStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.AndesiteStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.GraniteStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.DioriteStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.TuffStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.BasaltStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.BlackstoneStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.PolishedTuffStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.DeepslateStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.SandstoneStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.RedSandstoneStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.BrickBlockStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.MudBricksStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.TuffBricksStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.OakPlanksStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.BirchPlanksStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.JunglePlanksStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.SprucePlanksStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.StoneSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.CobblestoneSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.StoneBricksSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.SmoothStoneSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.AndesiteSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.GraniteSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.DioriteSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.TuffSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.BasaltSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.BlackstoneSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.PolishedTuffSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.DeepslateSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.SandstoneSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.RedSandstoneSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.BrickBlockSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.MudBricksSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.TuffBricksSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.OakPlanksSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.BirchPlanksSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.JunglePlanksSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.SprucePlanksSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.StoneWall.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.CobblestoneWall.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.StoneBricksWall.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.AndesiteWall.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.GraniteWall.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.DioriteWall.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.TuffWall.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.BasaltWall.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.BlackstoneWall.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.PolishedGraniteWall.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.PolishedDioriteWall.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.PolishedTuffWall.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.PolishedBasaltWall.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.DeepslateWall.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.DeepslateBricksWall.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.SandstoneWall.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.RedSandstoneWall.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.BrickBlockWall.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.MudBricksWall.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.TuffBricksWall.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.OakFence.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.BirchFence.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.JungleFence.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.SakuraFence.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.AcaciaFence.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.SpruceFence.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.DarkOakFence.isLeaf(), "!isLeaf"); + assertFalse(ObjectTypes.MangroveFence.isLeaf(), "!isLeaf"); assertFalse(ObjectTypes.WoodenPick.isLeaf(), "!isLeaf"); assertFalse(ObjectTypes.CopperPick.isLeaf(), "!isLeaf"); assertFalse(ObjectTypes.IronPick.isLeaf(), "!isLeaf"); @@ -2237,6 +2951,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.isPlank(), "!isPlank"); assertFalse(ObjectTypes.Stick.isPlank(), "!isPlank"); assertFalse(ObjectTypes.Lodestone.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.StoneStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.CobblestoneStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.StoneBricksStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.SmoothStoneStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.AndesiteStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.GraniteStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.DioriteStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.TuffStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.BasaltStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.BlackstoneStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.PolishedTuffStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.DeepslateStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.SandstoneStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.RedSandstoneStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.BrickBlockStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.MudBricksStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.TuffBricksStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.OakPlanksStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.BirchPlanksStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.JunglePlanksStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.SprucePlanksStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.StoneSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.CobblestoneSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.StoneBricksSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.SmoothStoneSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.AndesiteSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.GraniteSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.DioriteSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.TuffSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.BasaltSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.BlackstoneSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.PolishedTuffSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.DeepslateSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.SandstoneSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.RedSandstoneSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.BrickBlockSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.MudBricksSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.TuffBricksSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.OakPlanksSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.BirchPlanksSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.JunglePlanksSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.SprucePlanksSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.StoneWall.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.CobblestoneWall.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.StoneBricksWall.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.AndesiteWall.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.GraniteWall.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.DioriteWall.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.TuffWall.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.BasaltWall.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.BlackstoneWall.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.PolishedGraniteWall.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.PolishedDioriteWall.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.PolishedTuffWall.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.PolishedBasaltWall.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.DeepslateWall.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.DeepslateBricksWall.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.SandstoneWall.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.RedSandstoneWall.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.BrickBlockWall.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.MudBricksWall.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.TuffBricksWall.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.OakFence.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.BirchFence.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.JungleFence.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.SakuraFence.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.AcaciaFence.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.SpruceFence.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.DarkOakFence.isPlank(), "!isPlank"); + assertFalse(ObjectTypes.MangroveFence.isPlank(), "!isPlank"); assertFalse(ObjectTypes.WoodenPick.isPlank(), "!isPlank"); assertFalse(ObjectTypes.CopperPick.isPlank(), "!isPlank"); assertFalse(ObjectTypes.IronPick.isPlank(), "!isPlank"); @@ -2520,6 +3336,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.isSeed(), "!isSeed"); assertFalse(ObjectTypes.Stick.isSeed(), "!isSeed"); assertFalse(ObjectTypes.Lodestone.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.StoneStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.CobblestoneStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.StoneBricksStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.SmoothStoneStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.AndesiteStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.GraniteStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.DioriteStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.TuffStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.BasaltStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.BlackstoneStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.PolishedTuffStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.DeepslateStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.SandstoneStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.RedSandstoneStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.BrickBlockStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.MudBricksStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.TuffBricksStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.OakPlanksStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.BirchPlanksStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.JunglePlanksStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.SprucePlanksStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.StoneSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.CobblestoneSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.StoneBricksSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.SmoothStoneSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.AndesiteSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.GraniteSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.DioriteSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.TuffSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.BasaltSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.BlackstoneSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.PolishedTuffSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.DeepslateSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.SandstoneSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.RedSandstoneSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.BrickBlockSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.MudBricksSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.TuffBricksSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.OakPlanksSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.BirchPlanksSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.JunglePlanksSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.SprucePlanksSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.StoneWall.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.CobblestoneWall.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.StoneBricksWall.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.AndesiteWall.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.GraniteWall.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.DioriteWall.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.TuffWall.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.BasaltWall.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.BlackstoneWall.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.PolishedGraniteWall.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.PolishedDioriteWall.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.PolishedTuffWall.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.PolishedBasaltWall.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.DeepslateWall.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.DeepslateBricksWall.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.SandstoneWall.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.RedSandstoneWall.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.BrickBlockWall.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.MudBricksWall.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.TuffBricksWall.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.OakFence.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.BirchFence.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.JungleFence.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.SakuraFence.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.AcaciaFence.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.SpruceFence.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.DarkOakFence.isSeed(), "!isSeed"); + assertFalse(ObjectTypes.MangroveFence.isSeed(), "!isSeed"); assertFalse(ObjectTypes.WoodenPick.isSeed(), "!isSeed"); assertFalse(ObjectTypes.CopperPick.isSeed(), "!isSeed"); assertFalse(ObjectTypes.IronPick.isSeed(), "!isSeed"); @@ -2803,6 +3721,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.isSapling(), "!isSapling"); assertFalse(ObjectTypes.Stick.isSapling(), "!isSapling"); assertFalse(ObjectTypes.Lodestone.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.StoneStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.CobblestoneStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.StoneBricksStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.SmoothStoneStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.AndesiteStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.GraniteStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.DioriteStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.TuffStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.BasaltStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.BlackstoneStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.PolishedTuffStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.DeepslateStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.SandstoneStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.RedSandstoneStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.BrickBlockStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.MudBricksStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.TuffBricksStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.OakPlanksStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.BirchPlanksStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.JunglePlanksStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.SprucePlanksStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.StoneSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.CobblestoneSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.StoneBricksSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.SmoothStoneSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.AndesiteSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.GraniteSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.DioriteSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.TuffSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.BasaltSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.BlackstoneSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.PolishedTuffSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.DeepslateSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.SandstoneSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.RedSandstoneSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.BrickBlockSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.MudBricksSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.TuffBricksSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.OakPlanksSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.BirchPlanksSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.JunglePlanksSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.SprucePlanksSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.StoneWall.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.CobblestoneWall.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.StoneBricksWall.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.AndesiteWall.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.GraniteWall.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.DioriteWall.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.TuffWall.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.BasaltWall.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.BlackstoneWall.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.PolishedGraniteWall.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.PolishedDioriteWall.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.PolishedTuffWall.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.PolishedBasaltWall.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.DeepslateWall.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.DeepslateBricksWall.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.SandstoneWall.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.RedSandstoneWall.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.BrickBlockWall.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.MudBricksWall.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.TuffBricksWall.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.OakFence.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.BirchFence.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.JungleFence.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.SakuraFence.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.AcaciaFence.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.SpruceFence.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.DarkOakFence.isSapling(), "!isSapling"); + assertFalse(ObjectTypes.MangroveFence.isSapling(), "!isSapling"); assertFalse(ObjectTypes.WoodenPick.isSapling(), "!isSapling"); assertFalse(ObjectTypes.CopperPick.isSapling(), "!isSapling"); assertFalse(ObjectTypes.IronPick.isSapling(), "!isSapling"); @@ -3087,6 +4107,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.isSmartEntity(), "!isSmartEntity"); assertFalse(ObjectTypes.Stick.isSmartEntity(), "!isSmartEntity"); assertFalse(ObjectTypes.Lodestone.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.StoneStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.CobblestoneStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.StoneBricksStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.SmoothStoneStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.AndesiteStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.GraniteStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.DioriteStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.TuffStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.BasaltStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.BlackstoneStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.PolishedTuffStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.DeepslateStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.SandstoneStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.RedSandstoneStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.BrickBlockStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.MudBricksStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.TuffBricksStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.OakPlanksStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.BirchPlanksStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.JunglePlanksStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.SprucePlanksStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.StoneSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.CobblestoneSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.StoneBricksSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.SmoothStoneSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.AndesiteSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.GraniteSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.DioriteSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.TuffSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.BasaltSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.BlackstoneSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.PolishedTuffSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.DeepslateSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.SandstoneSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.RedSandstoneSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.BrickBlockSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.MudBricksSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.TuffBricksSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.OakPlanksSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.BirchPlanksSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.JunglePlanksSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.SprucePlanksSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.StoneWall.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.CobblestoneWall.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.StoneBricksWall.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.AndesiteWall.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.GraniteWall.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.DioriteWall.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.TuffWall.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.BasaltWall.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.BlackstoneWall.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.PolishedGraniteWall.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.PolishedDioriteWall.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.PolishedTuffWall.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.PolishedBasaltWall.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.DeepslateWall.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.DeepslateBricksWall.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.SandstoneWall.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.RedSandstoneWall.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.BrickBlockWall.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.MudBricksWall.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.TuffBricksWall.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.OakFence.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.BirchFence.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.JungleFence.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.SakuraFence.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.AcaciaFence.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.SpruceFence.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.DarkOakFence.isSmartEntity(), "!isSmartEntity"); + assertFalse(ObjectTypes.MangroveFence.isSmartEntity(), "!isSmartEntity"); assertFalse(ObjectTypes.WoodenPick.isSmartEntity(), "!isSmartEntity"); assertFalse(ObjectTypes.CopperPick.isSmartEntity(), "!isSmartEntity"); assertFalse(ObjectTypes.IronPick.isSmartEntity(), "!isSmartEntity"); @@ -3369,6 +4491,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.isStation(), "!isStation"); assertFalse(ObjectTypes.Stick.isStation(), "!isStation"); assertFalse(ObjectTypes.Lodestone.isStation(), "!isStation"); + assertFalse(ObjectTypes.StoneStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.CobblestoneStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.StoneBricksStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.SmoothStoneStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.AndesiteStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.GraniteStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.DioriteStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.TuffStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.BasaltStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.BlackstoneStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.PolishedTuffStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.DeepslateStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.SandstoneStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.RedSandstoneStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.BrickBlockStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.MudBricksStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.TuffBricksStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.OakPlanksStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.BirchPlanksStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.JunglePlanksStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.SprucePlanksStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isStation(), "!isStation"); + assertFalse(ObjectTypes.StoneSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.CobblestoneSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.StoneBricksSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.SmoothStoneSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.AndesiteSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.GraniteSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.DioriteSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.TuffSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.BasaltSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.BlackstoneSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.PolishedTuffSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.DeepslateSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.SandstoneSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.RedSandstoneSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.BrickBlockSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.MudBricksSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.TuffBricksSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.OakPlanksSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.BirchPlanksSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.JunglePlanksSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.SprucePlanksSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isStation(), "!isStation"); + assertFalse(ObjectTypes.StoneWall.isStation(), "!isStation"); + assertFalse(ObjectTypes.CobblestoneWall.isStation(), "!isStation"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isStation(), "!isStation"); + assertFalse(ObjectTypes.StoneBricksWall.isStation(), "!isStation"); + assertFalse(ObjectTypes.AndesiteWall.isStation(), "!isStation"); + assertFalse(ObjectTypes.GraniteWall.isStation(), "!isStation"); + assertFalse(ObjectTypes.DioriteWall.isStation(), "!isStation"); + assertFalse(ObjectTypes.TuffWall.isStation(), "!isStation"); + assertFalse(ObjectTypes.BasaltWall.isStation(), "!isStation"); + assertFalse(ObjectTypes.BlackstoneWall.isStation(), "!isStation"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isStation(), "!isStation"); + assertFalse(ObjectTypes.PolishedGraniteWall.isStation(), "!isStation"); + assertFalse(ObjectTypes.PolishedDioriteWall.isStation(), "!isStation"); + assertFalse(ObjectTypes.PolishedTuffWall.isStation(), "!isStation"); + assertFalse(ObjectTypes.PolishedBasaltWall.isStation(), "!isStation"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isStation(), "!isStation"); + assertFalse(ObjectTypes.DeepslateWall.isStation(), "!isStation"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isStation(), "!isStation"); + assertFalse(ObjectTypes.DeepslateBricksWall.isStation(), "!isStation"); + assertFalse(ObjectTypes.SandstoneWall.isStation(), "!isStation"); + assertFalse(ObjectTypes.RedSandstoneWall.isStation(), "!isStation"); + assertFalse(ObjectTypes.BrickBlockWall.isStation(), "!isStation"); + assertFalse(ObjectTypes.MudBricksWall.isStation(), "!isStation"); + assertFalse(ObjectTypes.TuffBricksWall.isStation(), "!isStation"); + assertFalse(ObjectTypes.OakFence.isStation(), "!isStation"); + assertFalse(ObjectTypes.BirchFence.isStation(), "!isStation"); + assertFalse(ObjectTypes.JungleFence.isStation(), "!isStation"); + assertFalse(ObjectTypes.SakuraFence.isStation(), "!isStation"); + assertFalse(ObjectTypes.AcaciaFence.isStation(), "!isStation"); + assertFalse(ObjectTypes.SpruceFence.isStation(), "!isStation"); + assertFalse(ObjectTypes.DarkOakFence.isStation(), "!isStation"); + assertFalse(ObjectTypes.MangroveFence.isStation(), "!isStation"); assertFalse(ObjectTypes.WoodenPick.isStation(), "!isStation"); assertFalse(ObjectTypes.CopperPick.isStation(), "!isStation"); assertFalse(ObjectTypes.IronPick.isStation(), "!isStation"); @@ -3658,6 +4882,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.isPick(), "!isPick"); assertFalse(ObjectTypes.Stick.isPick(), "!isPick"); assertFalse(ObjectTypes.Lodestone.isPick(), "!isPick"); + assertFalse(ObjectTypes.StoneStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.CobblestoneStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.StoneBricksStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.SmoothStoneStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.AndesiteStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.GraniteStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.DioriteStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.TuffStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.BasaltStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.BlackstoneStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.PolishedTuffStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.DeepslateStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.SandstoneStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.RedSandstoneStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.BrickBlockStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.MudBricksStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.TuffBricksStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.OakPlanksStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.BirchPlanksStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.JunglePlanksStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.SprucePlanksStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isPick(), "!isPick"); + assertFalse(ObjectTypes.StoneSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.CobblestoneSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.StoneBricksSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.SmoothStoneSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.AndesiteSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.GraniteSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.DioriteSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.TuffSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.BasaltSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.BlackstoneSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.PolishedTuffSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.DeepslateSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.SandstoneSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.RedSandstoneSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.BrickBlockSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.MudBricksSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.TuffBricksSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.OakPlanksSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.BirchPlanksSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.JunglePlanksSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.SprucePlanksSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isPick(), "!isPick"); + assertFalse(ObjectTypes.StoneWall.isPick(), "!isPick"); + assertFalse(ObjectTypes.CobblestoneWall.isPick(), "!isPick"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isPick(), "!isPick"); + assertFalse(ObjectTypes.StoneBricksWall.isPick(), "!isPick"); + assertFalse(ObjectTypes.AndesiteWall.isPick(), "!isPick"); + assertFalse(ObjectTypes.GraniteWall.isPick(), "!isPick"); + assertFalse(ObjectTypes.DioriteWall.isPick(), "!isPick"); + assertFalse(ObjectTypes.TuffWall.isPick(), "!isPick"); + assertFalse(ObjectTypes.BasaltWall.isPick(), "!isPick"); + assertFalse(ObjectTypes.BlackstoneWall.isPick(), "!isPick"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isPick(), "!isPick"); + assertFalse(ObjectTypes.PolishedGraniteWall.isPick(), "!isPick"); + assertFalse(ObjectTypes.PolishedDioriteWall.isPick(), "!isPick"); + assertFalse(ObjectTypes.PolishedTuffWall.isPick(), "!isPick"); + assertFalse(ObjectTypes.PolishedBasaltWall.isPick(), "!isPick"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isPick(), "!isPick"); + assertFalse(ObjectTypes.DeepslateWall.isPick(), "!isPick"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isPick(), "!isPick"); + assertFalse(ObjectTypes.DeepslateBricksWall.isPick(), "!isPick"); + assertFalse(ObjectTypes.SandstoneWall.isPick(), "!isPick"); + assertFalse(ObjectTypes.RedSandstoneWall.isPick(), "!isPick"); + assertFalse(ObjectTypes.BrickBlockWall.isPick(), "!isPick"); + assertFalse(ObjectTypes.MudBricksWall.isPick(), "!isPick"); + assertFalse(ObjectTypes.TuffBricksWall.isPick(), "!isPick"); + assertFalse(ObjectTypes.OakFence.isPick(), "!isPick"); + assertFalse(ObjectTypes.BirchFence.isPick(), "!isPick"); + assertFalse(ObjectTypes.JungleFence.isPick(), "!isPick"); + assertFalse(ObjectTypes.SakuraFence.isPick(), "!isPick"); + assertFalse(ObjectTypes.AcaciaFence.isPick(), "!isPick"); + assertFalse(ObjectTypes.SpruceFence.isPick(), "!isPick"); + assertFalse(ObjectTypes.DarkOakFence.isPick(), "!isPick"); + assertFalse(ObjectTypes.MangroveFence.isPick(), "!isPick"); assertFalse(ObjectTypes.WoodenAxe.isPick(), "!isPick"); assertFalse(ObjectTypes.CopperAxe.isPick(), "!isPick"); assertFalse(ObjectTypes.IronAxe.isPick(), "!isPick"); @@ -3941,6 +5267,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.isAxe(), "!isAxe"); assertFalse(ObjectTypes.Stick.isAxe(), "!isAxe"); assertFalse(ObjectTypes.Lodestone.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.StoneStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.CobblestoneStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.StoneBricksStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.SmoothStoneStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.AndesiteStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.GraniteStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.DioriteStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.TuffStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.BasaltStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.BlackstoneStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.PolishedTuffStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.DeepslateStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.SandstoneStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.RedSandstoneStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.BrickBlockStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.MudBricksStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.TuffBricksStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.OakPlanksStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.BirchPlanksStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.JunglePlanksStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.SprucePlanksStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.StoneSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.CobblestoneSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.StoneBricksSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.SmoothStoneSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.AndesiteSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.GraniteSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.DioriteSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.TuffSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.BasaltSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.BlackstoneSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.PolishedTuffSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.DeepslateSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.SandstoneSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.RedSandstoneSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.BrickBlockSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.MudBricksSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.TuffBricksSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.OakPlanksSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.BirchPlanksSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.JunglePlanksSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.SprucePlanksSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.StoneWall.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.CobblestoneWall.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.StoneBricksWall.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.AndesiteWall.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.GraniteWall.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.DioriteWall.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.TuffWall.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.BasaltWall.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.BlackstoneWall.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.PolishedGraniteWall.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.PolishedDioriteWall.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.PolishedTuffWall.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.PolishedBasaltWall.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.DeepslateWall.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.DeepslateBricksWall.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.SandstoneWall.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.RedSandstoneWall.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.BrickBlockWall.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.MudBricksWall.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.TuffBricksWall.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.OakFence.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.BirchFence.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.JungleFence.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.SakuraFence.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.AcaciaFence.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.SpruceFence.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.DarkOakFence.isAxe(), "!isAxe"); + assertFalse(ObjectTypes.MangroveFence.isAxe(), "!isAxe"); assertFalse(ObjectTypes.WoodenPick.isAxe(), "!isAxe"); assertFalse(ObjectTypes.CopperPick.isAxe(), "!isAxe"); assertFalse(ObjectTypes.IronPick.isAxe(), "!isAxe"); @@ -4219,6 +5647,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.isHoe(), "!isHoe"); assertFalse(ObjectTypes.Stick.isHoe(), "!isHoe"); assertFalse(ObjectTypes.Lodestone.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.StoneStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.CobblestoneStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.StoneBricksStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.SmoothStoneStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.AndesiteStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.GraniteStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.DioriteStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.TuffStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.BasaltStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.BlackstoneStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.PolishedTuffStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.DeepslateStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.SandstoneStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.RedSandstoneStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.BrickBlockStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.MudBricksStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.TuffBricksStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.OakPlanksStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.BirchPlanksStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.JunglePlanksStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.SprucePlanksStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.StoneSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.CobblestoneSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.StoneBricksSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.SmoothStoneSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.AndesiteSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.GraniteSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.DioriteSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.TuffSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.BasaltSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.BlackstoneSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.PolishedTuffSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.DeepslateSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.SandstoneSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.RedSandstoneSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.BrickBlockSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.MudBricksSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.TuffBricksSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.OakPlanksSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.BirchPlanksSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.JunglePlanksSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.SprucePlanksSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.StoneWall.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.CobblestoneWall.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.StoneBricksWall.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.AndesiteWall.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.GraniteWall.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.DioriteWall.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.TuffWall.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.BasaltWall.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.BlackstoneWall.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.PolishedGraniteWall.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.PolishedDioriteWall.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.PolishedTuffWall.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.PolishedBasaltWall.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.DeepslateWall.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.DeepslateBricksWall.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.SandstoneWall.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.RedSandstoneWall.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.BrickBlockWall.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.MudBricksWall.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.TuffBricksWall.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.OakFence.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.BirchFence.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.JungleFence.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.SakuraFence.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.AcaciaFence.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.SpruceFence.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.DarkOakFence.isHoe(), "!isHoe"); + assertFalse(ObjectTypes.MangroveFence.isHoe(), "!isHoe"); assertFalse(ObjectTypes.WoodenPick.isHoe(), "!isHoe"); assertFalse(ObjectTypes.CopperPick.isHoe(), "!isHoe"); assertFalse(ObjectTypes.IronPick.isHoe(), "!isHoe"); @@ -4504,6 +6034,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.isWhacker(), "!isWhacker"); assertFalse(ObjectTypes.Stick.isWhacker(), "!isWhacker"); assertFalse(ObjectTypes.Lodestone.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.StoneStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.CobblestoneStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.StoneBricksStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.SmoothStoneStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.AndesiteStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.GraniteStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.DioriteStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.TuffStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.BasaltStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.BlackstoneStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.PolishedTuffStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.DeepslateStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.SandstoneStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.RedSandstoneStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.BrickBlockStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.MudBricksStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.TuffBricksStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.OakPlanksStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.BirchPlanksStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.JunglePlanksStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.SprucePlanksStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.StoneSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.CobblestoneSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.StoneBricksSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.SmoothStoneSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.AndesiteSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.GraniteSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.DioriteSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.TuffSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.BasaltSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.BlackstoneSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.PolishedTuffSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.DeepslateSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.SandstoneSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.RedSandstoneSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.BrickBlockSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.MudBricksSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.TuffBricksSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.OakPlanksSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.BirchPlanksSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.JunglePlanksSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.SprucePlanksSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.StoneWall.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.CobblestoneWall.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.StoneBricksWall.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.AndesiteWall.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.GraniteWall.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.DioriteWall.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.TuffWall.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.BasaltWall.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.BlackstoneWall.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.PolishedGraniteWall.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.PolishedDioriteWall.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.PolishedTuffWall.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.PolishedBasaltWall.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.DeepslateWall.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.DeepslateBricksWall.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.SandstoneWall.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.RedSandstoneWall.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.BrickBlockWall.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.MudBricksWall.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.TuffBricksWall.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.OakFence.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.BirchFence.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.JungleFence.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.SakuraFence.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.AcaciaFence.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.SpruceFence.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.DarkOakFence.isWhacker(), "!isWhacker"); + assertFalse(ObjectTypes.MangroveFence.isWhacker(), "!isWhacker"); assertFalse(ObjectTypes.WoodenPick.isWhacker(), "!isWhacker"); assertFalse(ObjectTypes.CopperPick.isWhacker(), "!isWhacker"); assertFalse(ObjectTypes.IronPick.isWhacker(), "!isWhacker"); @@ -4788,6 +6420,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.isOreBar(), "!isOreBar"); assertFalse(ObjectTypes.Stick.isOreBar(), "!isOreBar"); assertFalse(ObjectTypes.Lodestone.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.StoneStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.CobblestoneStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.StoneBricksStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.SmoothStoneStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.AndesiteStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.GraniteStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.DioriteStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.TuffStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.BasaltStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.BlackstoneStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.PolishedTuffStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.DeepslateStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.SandstoneStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.RedSandstoneStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.BrickBlockStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.MudBricksStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.TuffBricksStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.OakPlanksStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.BirchPlanksStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.JunglePlanksStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.SprucePlanksStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.StoneSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.CobblestoneSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.StoneBricksSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.SmoothStoneSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.AndesiteSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.GraniteSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.DioriteSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.TuffSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.BasaltSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.BlackstoneSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.PolishedTuffSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.DeepslateSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.SandstoneSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.RedSandstoneSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.BrickBlockSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.MudBricksSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.TuffBricksSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.OakPlanksSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.BirchPlanksSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.JunglePlanksSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.SprucePlanksSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.StoneWall.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.CobblestoneWall.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.StoneBricksWall.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.AndesiteWall.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.GraniteWall.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.DioriteWall.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.TuffWall.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.BasaltWall.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.BlackstoneWall.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.PolishedGraniteWall.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.PolishedDioriteWall.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.PolishedTuffWall.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.PolishedBasaltWall.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.DeepslateWall.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.DeepslateBricksWall.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.SandstoneWall.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.RedSandstoneWall.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.BrickBlockWall.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.MudBricksWall.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.TuffBricksWall.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.OakFence.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.BirchFence.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.JungleFence.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.SakuraFence.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.AcaciaFence.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.SpruceFence.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.DarkOakFence.isOreBar(), "!isOreBar"); + assertFalse(ObjectTypes.MangroveFence.isOreBar(), "!isOreBar"); assertFalse(ObjectTypes.WoodenPick.isOreBar(), "!isOreBar"); assertFalse(ObjectTypes.CopperPick.isOreBar(), "!isOreBar"); assertFalse(ObjectTypes.IronPick.isOreBar(), "!isOreBar"); @@ -5070,6 +6804,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.isFood(), "!isFood"); assertFalse(ObjectTypes.Stick.isFood(), "!isFood"); assertFalse(ObjectTypes.Lodestone.isFood(), "!isFood"); + assertFalse(ObjectTypes.StoneStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.CobblestoneStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.StoneBricksStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.SmoothStoneStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.AndesiteStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.GraniteStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.DioriteStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.TuffStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.BasaltStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.BlackstoneStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.PolishedTuffStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.DeepslateStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.SandstoneStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.RedSandstoneStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.BrickBlockStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.MudBricksStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.TuffBricksStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.OakPlanksStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.BirchPlanksStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.JunglePlanksStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.SprucePlanksStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isFood(), "!isFood"); + assertFalse(ObjectTypes.StoneSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.CobblestoneSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.StoneBricksSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.SmoothStoneSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.AndesiteSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.GraniteSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.DioriteSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.TuffSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.BasaltSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.BlackstoneSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.PolishedTuffSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.DeepslateSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.SandstoneSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.RedSandstoneSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.BrickBlockSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.MudBricksSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.TuffBricksSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.OakPlanksSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.BirchPlanksSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.JunglePlanksSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.SprucePlanksSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isFood(), "!isFood"); + assertFalse(ObjectTypes.StoneWall.isFood(), "!isFood"); + assertFalse(ObjectTypes.CobblestoneWall.isFood(), "!isFood"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isFood(), "!isFood"); + assertFalse(ObjectTypes.StoneBricksWall.isFood(), "!isFood"); + assertFalse(ObjectTypes.AndesiteWall.isFood(), "!isFood"); + assertFalse(ObjectTypes.GraniteWall.isFood(), "!isFood"); + assertFalse(ObjectTypes.DioriteWall.isFood(), "!isFood"); + assertFalse(ObjectTypes.TuffWall.isFood(), "!isFood"); + assertFalse(ObjectTypes.BasaltWall.isFood(), "!isFood"); + assertFalse(ObjectTypes.BlackstoneWall.isFood(), "!isFood"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isFood(), "!isFood"); + assertFalse(ObjectTypes.PolishedGraniteWall.isFood(), "!isFood"); + assertFalse(ObjectTypes.PolishedDioriteWall.isFood(), "!isFood"); + assertFalse(ObjectTypes.PolishedTuffWall.isFood(), "!isFood"); + assertFalse(ObjectTypes.PolishedBasaltWall.isFood(), "!isFood"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isFood(), "!isFood"); + assertFalse(ObjectTypes.DeepslateWall.isFood(), "!isFood"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isFood(), "!isFood"); + assertFalse(ObjectTypes.DeepslateBricksWall.isFood(), "!isFood"); + assertFalse(ObjectTypes.SandstoneWall.isFood(), "!isFood"); + assertFalse(ObjectTypes.RedSandstoneWall.isFood(), "!isFood"); + assertFalse(ObjectTypes.BrickBlockWall.isFood(), "!isFood"); + assertFalse(ObjectTypes.MudBricksWall.isFood(), "!isFood"); + assertFalse(ObjectTypes.TuffBricksWall.isFood(), "!isFood"); + assertFalse(ObjectTypes.OakFence.isFood(), "!isFood"); + assertFalse(ObjectTypes.BirchFence.isFood(), "!isFood"); + assertFalse(ObjectTypes.JungleFence.isFood(), "!isFood"); + assertFalse(ObjectTypes.SakuraFence.isFood(), "!isFood"); + assertFalse(ObjectTypes.AcaciaFence.isFood(), "!isFood"); + assertFalse(ObjectTypes.SpruceFence.isFood(), "!isFood"); + assertFalse(ObjectTypes.DarkOakFence.isFood(), "!isFood"); + assertFalse(ObjectTypes.MangroveFence.isFood(), "!isFood"); assertFalse(ObjectTypes.WoodenPick.isFood(), "!isFood"); assertFalse(ObjectTypes.CopperPick.isFood(), "!isFood"); assertFalse(ObjectTypes.IronPick.isFood(), "!isFood"); @@ -5351,6 +7187,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.isFuel(), "!isFuel"); assertFalse(ObjectTypes.Stick.isFuel(), "!isFuel"); assertFalse(ObjectTypes.Lodestone.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.StoneStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.CobblestoneStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.StoneBricksStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.SmoothStoneStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.AndesiteStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.GraniteStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.DioriteStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.TuffStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.BasaltStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.BlackstoneStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.PolishedTuffStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.DeepslateStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.SandstoneStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.RedSandstoneStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.BrickBlockStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.MudBricksStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.TuffBricksStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.OakPlanksStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.BirchPlanksStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.JunglePlanksStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.SprucePlanksStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.StoneSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.CobblestoneSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.StoneBricksSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.SmoothStoneSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.AndesiteSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.GraniteSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.DioriteSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.TuffSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.BasaltSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.BlackstoneSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.PolishedTuffSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.DeepslateSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.SandstoneSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.RedSandstoneSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.BrickBlockSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.MudBricksSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.TuffBricksSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.OakPlanksSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.BirchPlanksSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.JunglePlanksSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.SprucePlanksSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.StoneWall.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.CobblestoneWall.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.StoneBricksWall.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.AndesiteWall.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.GraniteWall.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.DioriteWall.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.TuffWall.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.BasaltWall.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.BlackstoneWall.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.PolishedGraniteWall.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.PolishedDioriteWall.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.PolishedTuffWall.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.PolishedBasaltWall.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.DeepslateWall.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.DeepslateBricksWall.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.SandstoneWall.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.RedSandstoneWall.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.BrickBlockWall.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.MudBricksWall.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.TuffBricksWall.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.OakFence.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.BirchFence.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.JungleFence.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.SakuraFence.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.AcaciaFence.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.SpruceFence.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.DarkOakFence.isFuel(), "!isFuel"); + assertFalse(ObjectTypes.MangroveFence.isFuel(), "!isFuel"); assertFalse(ObjectTypes.WoodenPick.isFuel(), "!isFuel"); assertFalse(ObjectTypes.CopperPick.isFuel(), "!isFuel"); assertFalse(ObjectTypes.IronPick.isFuel(), "!isFuel"); @@ -5634,6 +7572,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.isPlayer(), "!isPlayer"); assertFalse(ObjectTypes.Stick.isPlayer(), "!isPlayer"); assertFalse(ObjectTypes.Lodestone.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.StoneStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.CobblestoneStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.StoneBricksStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.SmoothStoneStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.AndesiteStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.GraniteStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.DioriteStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.TuffStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.BasaltStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.BlackstoneStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.PolishedTuffStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.DeepslateStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.SandstoneStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.RedSandstoneStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.BrickBlockStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.MudBricksStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.TuffBricksStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.OakPlanksStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.BirchPlanksStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.JunglePlanksStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.SprucePlanksStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.StoneSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.CobblestoneSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.StoneBricksSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.SmoothStoneSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.AndesiteSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.GraniteSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.DioriteSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.TuffSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.BasaltSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.BlackstoneSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.PolishedTuffSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.DeepslateSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.SandstoneSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.RedSandstoneSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.BrickBlockSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.MudBricksSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.TuffBricksSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.OakPlanksSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.BirchPlanksSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.JunglePlanksSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.SprucePlanksSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.StoneWall.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.CobblestoneWall.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.StoneBricksWall.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.AndesiteWall.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.GraniteWall.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.DioriteWall.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.TuffWall.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.BasaltWall.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.BlackstoneWall.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.PolishedGraniteWall.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.PolishedDioriteWall.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.PolishedTuffWall.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.PolishedBasaltWall.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.DeepslateWall.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.DeepslateBricksWall.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.SandstoneWall.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.RedSandstoneWall.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.BrickBlockWall.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.MudBricksWall.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.TuffBricksWall.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.OakFence.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.BirchFence.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.JungleFence.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.SakuraFence.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.AcaciaFence.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.SpruceFence.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.DarkOakFence.isPlayer(), "!isPlayer"); + assertFalse(ObjectTypes.MangroveFence.isPlayer(), "!isPlayer"); assertFalse(ObjectTypes.WoodenPick.isPlayer(), "!isPlayer"); assertFalse(ObjectTypes.CopperPick.isPlayer(), "!isPlayer"); assertFalse(ObjectTypes.IronPick.isPlayer(), "!isPlayer"); @@ -5916,6 +7956,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.hasExtraDrops(), "!hasExtraDrops"); assertFalse(ObjectTypes.Stick.hasExtraDrops(), "!hasExtraDrops"); assertFalse(ObjectTypes.Lodestone.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.StoneStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.CobblestoneStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.StoneBricksStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.SmoothStoneStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.AndesiteStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.GraniteStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.DioriteStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.TuffStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.BasaltStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.BlackstoneStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.PolishedGraniteStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.PolishedDioriteStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.PolishedTuffStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.PolishedBasaltStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.DeepslateStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.DeepslateBricksStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.SandstoneStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.RedSandstoneStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.BrickBlockStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.MudBricksStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.TuffBricksStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.OakPlanksStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.BirchPlanksStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.JunglePlanksStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.SakuraPlanksStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.SprucePlanksStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.MangrovePlanksStairs.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.StoneSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.CobblestoneSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.StoneBricksSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.SmoothStoneSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.AndesiteSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.GraniteSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.DioriteSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.TuffSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.BasaltSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.BlackstoneSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.PolishedGraniteSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.PolishedDioriteSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.PolishedTuffSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.PolishedBasaltSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.DeepslateSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.DeepslateBricksSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.SandstoneSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.RedSandstoneSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.BrickBlockSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.MudBricksSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.TuffBricksSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.OakPlanksSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.BirchPlanksSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.JunglePlanksSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.SakuraPlanksSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.SprucePlanksSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.MangrovePlanksSlab.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.StoneWall.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.CobblestoneWall.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.MossyCobblestoneWall.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.StoneBricksWall.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.AndesiteWall.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.GraniteWall.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.DioriteWall.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.TuffWall.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.BasaltWall.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.BlackstoneWall.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.PolishedAndesiteWall.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.PolishedGraniteWall.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.PolishedDioriteWall.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.PolishedTuffWall.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.PolishedBasaltWall.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.DeepslateWall.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.CobbledDeepslateWall.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.DeepslateBricksWall.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.SandstoneWall.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.RedSandstoneWall.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.BrickBlockWall.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.MudBricksWall.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.TuffBricksWall.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.OakFence.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.BirchFence.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.JungleFence.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.SakuraFence.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.AcaciaFence.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.SpruceFence.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.DarkOakFence.hasExtraDrops(), "!hasExtraDrops"); + assertFalse(ObjectTypes.MangroveFence.hasExtraDrops(), "!hasExtraDrops"); assertFalse(ObjectTypes.WoodenPick.hasExtraDrops(), "!hasExtraDrops"); assertFalse(ObjectTypes.CopperPick.hasExtraDrops(), "!hasExtraDrops"); assertFalse(ObjectTypes.IronPick.hasExtraDrops(), "!hasExtraDrops"); @@ -6199,6 +8341,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.hasAxeMultiplier(), "!hasAxeMultiplier"); assertFalse(ObjectTypes.Stick.hasAxeMultiplier(), "!hasAxeMultiplier"); assertFalse(ObjectTypes.Lodestone.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.StoneStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.CobblestoneStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.StoneBricksStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.SmoothStoneStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.AndesiteStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.GraniteStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.DioriteStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.TuffStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.BasaltStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.BlackstoneStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.PolishedGraniteStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.PolishedDioriteStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.PolishedTuffStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.PolishedBasaltStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.DeepslateStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.DeepslateBricksStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.SandstoneStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.RedSandstoneStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.BrickBlockStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.MudBricksStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.TuffBricksStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.OakPlanksStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.BirchPlanksStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.JunglePlanksStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.SakuraPlanksStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.SprucePlanksStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.MangrovePlanksStairs.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.StoneSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.CobblestoneSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.StoneBricksSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.SmoothStoneSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.AndesiteSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.GraniteSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.DioriteSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.TuffSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.BasaltSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.BlackstoneSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.PolishedGraniteSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.PolishedDioriteSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.PolishedTuffSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.PolishedBasaltSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.DeepslateSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.DeepslateBricksSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.SandstoneSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.RedSandstoneSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.BrickBlockSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.MudBricksSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.TuffBricksSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.OakPlanksSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.BirchPlanksSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.JunglePlanksSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.SakuraPlanksSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.SprucePlanksSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.MangrovePlanksSlab.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.StoneWall.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.CobblestoneWall.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.MossyCobblestoneWall.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.StoneBricksWall.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.AndesiteWall.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.GraniteWall.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.DioriteWall.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.TuffWall.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.BasaltWall.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.BlackstoneWall.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.PolishedAndesiteWall.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.PolishedGraniteWall.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.PolishedDioriteWall.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.PolishedTuffWall.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.PolishedBasaltWall.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.DeepslateWall.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.CobbledDeepslateWall.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.DeepslateBricksWall.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.SandstoneWall.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.RedSandstoneWall.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.BrickBlockWall.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.MudBricksWall.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.TuffBricksWall.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.OakFence.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.BirchFence.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.JungleFence.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.SakuraFence.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.AcaciaFence.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.SpruceFence.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.DarkOakFence.hasAxeMultiplier(), "!hasAxeMultiplier"); + assertFalse(ObjectTypes.MangroveFence.hasAxeMultiplier(), "!hasAxeMultiplier"); assertFalse(ObjectTypes.WoodenPick.hasAxeMultiplier(), "!hasAxeMultiplier"); assertFalse(ObjectTypes.CopperPick.hasAxeMultiplier(), "!hasAxeMultiplier"); assertFalse(ObjectTypes.IronPick.hasAxeMultiplier(), "!hasAxeMultiplier"); @@ -6482,6 +8726,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Brick.hasPickMultiplier(), "!hasPickMultiplier"); assertFalse(ObjectTypes.Paper.hasPickMultiplier(), "!hasPickMultiplier"); assertFalse(ObjectTypes.Stick.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.StoneStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.CobblestoneStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.StoneBricksStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.SmoothStoneStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.AndesiteStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.GraniteStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.DioriteStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.TuffStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.BasaltStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.BlackstoneStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.PolishedGraniteStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.PolishedDioriteStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.PolishedTuffStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.PolishedBasaltStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.DeepslateStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.DeepslateBricksStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.SandstoneStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.RedSandstoneStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.BrickBlockStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.MudBricksStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.TuffBricksStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.OakPlanksStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.BirchPlanksStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.JunglePlanksStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.SakuraPlanksStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.SprucePlanksStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.MangrovePlanksStairs.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.StoneSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.CobblestoneSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.StoneBricksSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.SmoothStoneSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.AndesiteSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.GraniteSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.DioriteSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.TuffSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.BasaltSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.BlackstoneSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.PolishedGraniteSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.PolishedDioriteSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.PolishedTuffSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.PolishedBasaltSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.DeepslateSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.DeepslateBricksSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.SandstoneSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.RedSandstoneSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.BrickBlockSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.MudBricksSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.TuffBricksSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.OakPlanksSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.BirchPlanksSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.JunglePlanksSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.SakuraPlanksSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.SprucePlanksSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.MangrovePlanksSlab.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.StoneWall.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.CobblestoneWall.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.MossyCobblestoneWall.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.StoneBricksWall.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.AndesiteWall.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.GraniteWall.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.DioriteWall.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.TuffWall.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.BasaltWall.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.BlackstoneWall.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.PolishedAndesiteWall.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.PolishedGraniteWall.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.PolishedDioriteWall.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.PolishedTuffWall.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.PolishedBasaltWall.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.DeepslateWall.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.CobbledDeepslateWall.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.DeepslateBricksWall.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.SandstoneWall.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.RedSandstoneWall.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.BrickBlockWall.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.MudBricksWall.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.TuffBricksWall.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.OakFence.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.BirchFence.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.JungleFence.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.SakuraFence.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.AcaciaFence.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.SpruceFence.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.DarkOakFence.hasPickMultiplier(), "!hasPickMultiplier"); + assertFalse(ObjectTypes.MangroveFence.hasPickMultiplier(), "!hasPickMultiplier"); assertFalse(ObjectTypes.WoodenPick.hasPickMultiplier(), "!hasPickMultiplier"); assertFalse(ObjectTypes.CopperPick.hasPickMultiplier(), "!hasPickMultiplier"); assertFalse(ObjectTypes.IronPick.hasPickMultiplier(), "!hasPickMultiplier"); @@ -6769,6 +9115,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.isWoodenTool(), "!isWoodenTool"); assertFalse(ObjectTypes.Stick.isWoodenTool(), "!isWoodenTool"); assertFalse(ObjectTypes.Lodestone.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.StoneStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.CobblestoneStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.StoneBricksStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.SmoothStoneStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.AndesiteStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.GraniteStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.DioriteStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.TuffStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.BasaltStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.BlackstoneStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.PolishedTuffStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.DeepslateStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.SandstoneStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.RedSandstoneStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.BrickBlockStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.MudBricksStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.TuffBricksStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.OakPlanksStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.BirchPlanksStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.JunglePlanksStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.SprucePlanksStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.StoneSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.CobblestoneSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.StoneBricksSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.SmoothStoneSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.AndesiteSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.GraniteSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.DioriteSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.TuffSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.BasaltSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.BlackstoneSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.PolishedTuffSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.DeepslateSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.SandstoneSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.RedSandstoneSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.BrickBlockSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.MudBricksSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.TuffBricksSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.OakPlanksSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.BirchPlanksSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.JunglePlanksSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.SprucePlanksSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.StoneWall.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.CobblestoneWall.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.StoneBricksWall.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.AndesiteWall.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.GraniteWall.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.DioriteWall.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.TuffWall.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.BasaltWall.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.BlackstoneWall.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.PolishedGraniteWall.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.PolishedDioriteWall.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.PolishedTuffWall.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.PolishedBasaltWall.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.DeepslateWall.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.DeepslateBricksWall.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.SandstoneWall.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.RedSandstoneWall.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.BrickBlockWall.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.MudBricksWall.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.TuffBricksWall.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.OakFence.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.BirchFence.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.JungleFence.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.SakuraFence.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.AcaciaFence.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.SpruceFence.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.DarkOakFence.isWoodenTool(), "!isWoodenTool"); + assertFalse(ObjectTypes.MangroveFence.isWoodenTool(), "!isWoodenTool"); assertFalse(ObjectTypes.CopperPick.isWoodenTool(), "!isWoodenTool"); assertFalse(ObjectTypes.IronPick.isWoodenTool(), "!isWoodenTool"); assertFalse(ObjectTypes.GoldPick.isWoodenTool(), "!isWoodenTool"); @@ -7048,6 +9496,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.isPassThrough(), "!isPassThrough"); assertFalse(ObjectTypes.Stick.isPassThrough(), "!isPassThrough"); assertFalse(ObjectTypes.Lodestone.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.StoneStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.CobblestoneStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.StoneBricksStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.SmoothStoneStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.AndesiteStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.GraniteStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.DioriteStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.TuffStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.BasaltStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.BlackstoneStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.PolishedTuffStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.DeepslateStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.SandstoneStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.RedSandstoneStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.BrickBlockStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.MudBricksStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.TuffBricksStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.OakPlanksStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.BirchPlanksStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.JunglePlanksStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.SprucePlanksStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.StoneSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.CobblestoneSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.StoneBricksSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.SmoothStoneSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.AndesiteSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.GraniteSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.DioriteSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.TuffSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.BasaltSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.BlackstoneSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.PolishedTuffSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.DeepslateSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.SandstoneSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.RedSandstoneSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.BrickBlockSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.MudBricksSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.TuffBricksSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.OakPlanksSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.BirchPlanksSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.JunglePlanksSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.SprucePlanksSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.StoneWall.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.CobblestoneWall.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.StoneBricksWall.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.AndesiteWall.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.GraniteWall.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.DioriteWall.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.TuffWall.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.BasaltWall.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.BlackstoneWall.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.PolishedGraniteWall.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.PolishedDioriteWall.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.PolishedTuffWall.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.PolishedBasaltWall.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.DeepslateWall.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.DeepslateBricksWall.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.SandstoneWall.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.RedSandstoneWall.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.BrickBlockWall.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.MudBricksWall.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.TuffBricksWall.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.OakFence.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.BirchFence.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.JungleFence.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.SakuraFence.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.AcaciaFence.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.SpruceFence.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.DarkOakFence.isPassThrough(), "!isPassThrough"); + assertFalse(ObjectTypes.MangroveFence.isPassThrough(), "!isPassThrough"); assertFalse(ObjectTypes.WoodenPick.isPassThrough(), "!isPassThrough"); assertFalse(ObjectTypes.CopperPick.isPassThrough(), "!isPassThrough"); assertFalse(ObjectTypes.IronPick.isPassThrough(), "!isPassThrough"); @@ -7331,6 +9881,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.isGrowable(), "!isGrowable"); assertFalse(ObjectTypes.Stick.isGrowable(), "!isGrowable"); assertFalse(ObjectTypes.Lodestone.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.StoneStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.CobblestoneStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.StoneBricksStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.SmoothStoneStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.AndesiteStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.GraniteStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.DioriteStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.TuffStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.BasaltStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.BlackstoneStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.PolishedTuffStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.DeepslateStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.SandstoneStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.RedSandstoneStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.BrickBlockStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.MudBricksStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.TuffBricksStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.OakPlanksStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.BirchPlanksStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.JunglePlanksStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.SprucePlanksStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.StoneSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.CobblestoneSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.StoneBricksSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.SmoothStoneSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.AndesiteSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.GraniteSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.DioriteSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.TuffSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.BasaltSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.BlackstoneSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.PolishedTuffSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.DeepslateSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.SandstoneSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.RedSandstoneSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.BrickBlockSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.MudBricksSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.TuffBricksSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.OakPlanksSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.BirchPlanksSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.JunglePlanksSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.SprucePlanksSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.StoneWall.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.CobblestoneWall.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.StoneBricksWall.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.AndesiteWall.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.GraniteWall.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.DioriteWall.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.TuffWall.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.BasaltWall.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.BlackstoneWall.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.PolishedGraniteWall.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.PolishedDioriteWall.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.PolishedTuffWall.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.PolishedBasaltWall.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.DeepslateWall.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.DeepslateBricksWall.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.SandstoneWall.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.RedSandstoneWall.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.BrickBlockWall.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.MudBricksWall.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.TuffBricksWall.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.OakFence.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.BirchFence.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.JungleFence.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.SakuraFence.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.AcaciaFence.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.SpruceFence.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.DarkOakFence.isGrowable(), "!isGrowable"); + assertFalse(ObjectTypes.MangroveFence.isGrowable(), "!isGrowable"); assertFalse(ObjectTypes.WoodenPick.isGrowable(), "!isGrowable"); assertFalse(ObjectTypes.CopperPick.isGrowable(), "!isGrowable"); assertFalse(ObjectTypes.IronPick.isGrowable(), "!isGrowable"); @@ -7614,6 +10266,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.isLandbound(), "!isLandbound"); assertFalse(ObjectTypes.Stick.isLandbound(), "!isLandbound"); assertFalse(ObjectTypes.Lodestone.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.StoneStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.CobblestoneStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.StoneBricksStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.SmoothStoneStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.AndesiteStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.GraniteStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.DioriteStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.TuffStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.BasaltStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.BlackstoneStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.PolishedTuffStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.DeepslateStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.SandstoneStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.RedSandstoneStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.BrickBlockStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.MudBricksStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.TuffBricksStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.OakPlanksStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.BirchPlanksStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.JunglePlanksStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.SprucePlanksStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.StoneSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.CobblestoneSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.StoneBricksSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.SmoothStoneSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.AndesiteSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.GraniteSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.DioriteSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.TuffSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.BasaltSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.BlackstoneSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.PolishedTuffSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.DeepslateSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.SandstoneSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.RedSandstoneSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.BrickBlockSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.MudBricksSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.TuffBricksSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.OakPlanksSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.BirchPlanksSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.JunglePlanksSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.SprucePlanksSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.StoneWall.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.CobblestoneWall.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.StoneBricksWall.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.AndesiteWall.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.GraniteWall.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.DioriteWall.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.TuffWall.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.BasaltWall.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.BlackstoneWall.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.PolishedGraniteWall.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.PolishedDioriteWall.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.PolishedTuffWall.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.PolishedBasaltWall.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.DeepslateWall.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.DeepslateBricksWall.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.SandstoneWall.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.RedSandstoneWall.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.BrickBlockWall.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.MudBricksWall.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.TuffBricksWall.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.OakFence.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.BirchFence.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.JungleFence.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.SakuraFence.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.AcaciaFence.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.SpruceFence.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.DarkOakFence.isLandbound(), "!isLandbound"); + assertFalse(ObjectTypes.MangroveFence.isLandbound(), "!isLandbound"); assertFalse(ObjectTypes.WoodenPick.isLandbound(), "!isLandbound"); assertFalse(ObjectTypes.CopperPick.isLandbound(), "!isLandbound"); assertFalse(ObjectTypes.IronPick.isLandbound(), "!isLandbound"); @@ -7915,6 +10669,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.isUniqueObject(), "!isUniqueObject"); assertFalse(ObjectTypes.Stick.isUniqueObject(), "!isUniqueObject"); assertFalse(ObjectTypes.Lodestone.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.StoneStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.CobblestoneStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.StoneBricksStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.SmoothStoneStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.AndesiteStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.GraniteStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.DioriteStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.TuffStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.BasaltStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.BlackstoneStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.PolishedTuffStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.DeepslateStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.SandstoneStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.RedSandstoneStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.BrickBlockStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.MudBricksStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.TuffBricksStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.OakPlanksStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.BirchPlanksStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.JunglePlanksStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.SprucePlanksStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.StoneSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.CobblestoneSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.StoneBricksSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.SmoothStoneSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.AndesiteSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.GraniteSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.DioriteSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.TuffSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.BasaltSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.BlackstoneSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.PolishedTuffSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.DeepslateSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.SandstoneSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.RedSandstoneSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.BrickBlockSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.MudBricksSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.TuffBricksSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.OakPlanksSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.BirchPlanksSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.JunglePlanksSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.SprucePlanksSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.StoneWall.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.CobblestoneWall.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.StoneBricksWall.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.AndesiteWall.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.GraniteWall.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.DioriteWall.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.TuffWall.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.BasaltWall.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.BlackstoneWall.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.PolishedGraniteWall.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.PolishedDioriteWall.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.PolishedTuffWall.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.PolishedBasaltWall.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.DeepslateWall.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.DeepslateBricksWall.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.SandstoneWall.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.RedSandstoneWall.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.BrickBlockWall.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.MudBricksWall.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.TuffBricksWall.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.OakFence.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.BirchFence.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.JungleFence.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.SakuraFence.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.AcaciaFence.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.SpruceFence.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.DarkOakFence.isUniqueObject(), "!isUniqueObject"); + assertFalse(ObjectTypes.MangroveFence.isUniqueObject(), "!isUniqueObject"); assertFalse(ObjectTypes.GoldBar.isUniqueObject(), "!isUniqueObject"); assertFalse(ObjectTypes.IronBar.isUniqueObject(), "!isUniqueObject"); assertFalse(ObjectTypes.Diamond.isUniqueObject(), "!isUniqueObject"); @@ -8196,6 +11052,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.isTool(), "!isTool"); assertFalse(ObjectTypes.Stick.isTool(), "!isTool"); assertFalse(ObjectTypes.Lodestone.isTool(), "!isTool"); + assertFalse(ObjectTypes.StoneStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.CobblestoneStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.StoneBricksStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.SmoothStoneStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.AndesiteStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.GraniteStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.DioriteStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.TuffStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.BasaltStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.BlackstoneStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.PolishedTuffStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.DeepslateStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.SandstoneStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.RedSandstoneStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.BrickBlockStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.MudBricksStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.TuffBricksStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.OakPlanksStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.BirchPlanksStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.JunglePlanksStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.SprucePlanksStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isTool(), "!isTool"); + assertFalse(ObjectTypes.StoneSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.CobblestoneSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.StoneBricksSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.SmoothStoneSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.AndesiteSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.GraniteSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.DioriteSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.TuffSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.BasaltSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.BlackstoneSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.PolishedTuffSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.DeepslateSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.SandstoneSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.RedSandstoneSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.BrickBlockSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.MudBricksSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.TuffBricksSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.OakPlanksSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.BirchPlanksSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.JunglePlanksSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.SprucePlanksSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isTool(), "!isTool"); + assertFalse(ObjectTypes.StoneWall.isTool(), "!isTool"); + assertFalse(ObjectTypes.CobblestoneWall.isTool(), "!isTool"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isTool(), "!isTool"); + assertFalse(ObjectTypes.StoneBricksWall.isTool(), "!isTool"); + assertFalse(ObjectTypes.AndesiteWall.isTool(), "!isTool"); + assertFalse(ObjectTypes.GraniteWall.isTool(), "!isTool"); + assertFalse(ObjectTypes.DioriteWall.isTool(), "!isTool"); + assertFalse(ObjectTypes.TuffWall.isTool(), "!isTool"); + assertFalse(ObjectTypes.BasaltWall.isTool(), "!isTool"); + assertFalse(ObjectTypes.BlackstoneWall.isTool(), "!isTool"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isTool(), "!isTool"); + assertFalse(ObjectTypes.PolishedGraniteWall.isTool(), "!isTool"); + assertFalse(ObjectTypes.PolishedDioriteWall.isTool(), "!isTool"); + assertFalse(ObjectTypes.PolishedTuffWall.isTool(), "!isTool"); + assertFalse(ObjectTypes.PolishedBasaltWall.isTool(), "!isTool"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isTool(), "!isTool"); + assertFalse(ObjectTypes.DeepslateWall.isTool(), "!isTool"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isTool(), "!isTool"); + assertFalse(ObjectTypes.DeepslateBricksWall.isTool(), "!isTool"); + assertFalse(ObjectTypes.SandstoneWall.isTool(), "!isTool"); + assertFalse(ObjectTypes.RedSandstoneWall.isTool(), "!isTool"); + assertFalse(ObjectTypes.BrickBlockWall.isTool(), "!isTool"); + assertFalse(ObjectTypes.MudBricksWall.isTool(), "!isTool"); + assertFalse(ObjectTypes.TuffBricksWall.isTool(), "!isTool"); + assertFalse(ObjectTypes.OakFence.isTool(), "!isTool"); + assertFalse(ObjectTypes.BirchFence.isTool(), "!isTool"); + assertFalse(ObjectTypes.JungleFence.isTool(), "!isTool"); + assertFalse(ObjectTypes.SakuraFence.isTool(), "!isTool"); + assertFalse(ObjectTypes.AcaciaFence.isTool(), "!isTool"); + assertFalse(ObjectTypes.SpruceFence.isTool(), "!isTool"); + assertFalse(ObjectTypes.DarkOakFence.isTool(), "!isTool"); + assertFalse(ObjectTypes.MangroveFence.isTool(), "!isTool"); assertFalse(ObjectTypes.GoldBar.isTool(), "!isTool"); assertFalse(ObjectTypes.IronBar.isTool(), "!isTool"); assertFalse(ObjectTypes.Diamond.isTool(), "!isTool"); @@ -8463,6 +11421,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.isTillable(), "!isTillable"); assertFalse(ObjectTypes.Stick.isTillable(), "!isTillable"); assertFalse(ObjectTypes.Lodestone.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.StoneStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.CobblestoneStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.StoneBricksStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.SmoothStoneStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.AndesiteStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.GraniteStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.DioriteStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.TuffStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.BasaltStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.BlackstoneStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.PolishedTuffStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.DeepslateStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.SandstoneStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.RedSandstoneStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.BrickBlockStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.MudBricksStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.TuffBricksStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.OakPlanksStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.BirchPlanksStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.JunglePlanksStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.SprucePlanksStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.StoneSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.CobblestoneSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.StoneBricksSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.SmoothStoneSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.AndesiteSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.GraniteSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.DioriteSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.TuffSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.BasaltSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.BlackstoneSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.PolishedTuffSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.DeepslateSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.SandstoneSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.RedSandstoneSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.BrickBlockSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.MudBricksSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.TuffBricksSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.OakPlanksSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.BirchPlanksSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.JunglePlanksSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.SprucePlanksSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.StoneWall.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.CobblestoneWall.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.StoneBricksWall.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.AndesiteWall.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.GraniteWall.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.DioriteWall.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.TuffWall.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.BasaltWall.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.BlackstoneWall.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.PolishedGraniteWall.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.PolishedDioriteWall.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.PolishedTuffWall.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.PolishedBasaltWall.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.DeepslateWall.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.DeepslateBricksWall.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.SandstoneWall.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.RedSandstoneWall.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.BrickBlockWall.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.MudBricksWall.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.TuffBricksWall.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.OakFence.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.BirchFence.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.JungleFence.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.SakuraFence.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.AcaciaFence.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.SpruceFence.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.DarkOakFence.isTillable(), "!isTillable"); + assertFalse(ObjectTypes.MangroveFence.isTillable(), "!isTillable"); assertFalse(ObjectTypes.WoodenPick.isTillable(), "!isTillable"); assertFalse(ObjectTypes.CopperPick.isTillable(), "!isTillable"); assertFalse(ObjectTypes.IronPick.isTillable(), "!isTillable"); @@ -8746,6 +11806,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.isMachine(), "!isMachine"); assertFalse(ObjectTypes.Stick.isMachine(), "!isMachine"); assertFalse(ObjectTypes.Lodestone.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.StoneStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.CobblestoneStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.StoneBricksStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.SmoothStoneStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.AndesiteStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.GraniteStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.DioriteStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.TuffStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.BasaltStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.BlackstoneStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.PolishedTuffStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.DeepslateStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.SandstoneStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.RedSandstoneStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.BrickBlockStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.MudBricksStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.TuffBricksStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.OakPlanksStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.BirchPlanksStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.JunglePlanksStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.SprucePlanksStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.StoneSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.CobblestoneSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.StoneBricksSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.SmoothStoneSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.AndesiteSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.GraniteSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.DioriteSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.TuffSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.BasaltSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.BlackstoneSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.PolishedTuffSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.DeepslateSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.SandstoneSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.RedSandstoneSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.BrickBlockSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.MudBricksSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.TuffBricksSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.OakPlanksSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.BirchPlanksSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.JunglePlanksSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.SprucePlanksSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.StoneWall.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.CobblestoneWall.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.StoneBricksWall.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.AndesiteWall.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.GraniteWall.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.DioriteWall.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.TuffWall.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.BasaltWall.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.BlackstoneWall.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.PolishedGraniteWall.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.PolishedDioriteWall.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.PolishedTuffWall.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.PolishedBasaltWall.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.DeepslateWall.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.DeepslateBricksWall.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.SandstoneWall.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.RedSandstoneWall.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.BrickBlockWall.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.MudBricksWall.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.TuffBricksWall.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.OakFence.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.BirchFence.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.JungleFence.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.SakuraFence.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.AcaciaFence.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.SpruceFence.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.DarkOakFence.isMachine(), "!isMachine"); + assertFalse(ObjectTypes.MangroveFence.isMachine(), "!isMachine"); assertFalse(ObjectTypes.WoodenPick.isMachine(), "!isMachine"); assertFalse(ObjectTypes.CopperPick.isMachine(), "!isMachine"); assertFalse(ObjectTypes.IronPick.isMachine(), "!isMachine"); @@ -9029,6 +12191,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.spawnsWithFluid(), "!spawnsWithFluid"); assertFalse(ObjectTypes.Stick.spawnsWithFluid(), "!spawnsWithFluid"); assertFalse(ObjectTypes.Lodestone.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.StoneStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.CobblestoneStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.StoneBricksStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.SmoothStoneStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.AndesiteStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.GraniteStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.DioriteStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.TuffStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.BasaltStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.BlackstoneStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.PolishedGraniteStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.PolishedDioriteStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.PolishedTuffStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.PolishedBasaltStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.DeepslateStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.DeepslateBricksStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.SandstoneStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.RedSandstoneStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.BrickBlockStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.MudBricksStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.TuffBricksStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.OakPlanksStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.BirchPlanksStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.JunglePlanksStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.SakuraPlanksStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.SprucePlanksStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.MangrovePlanksStairs.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.StoneSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.CobblestoneSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.StoneBricksSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.SmoothStoneSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.AndesiteSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.GraniteSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.DioriteSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.TuffSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.BasaltSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.BlackstoneSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.PolishedGraniteSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.PolishedDioriteSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.PolishedTuffSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.PolishedBasaltSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.DeepslateSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.DeepslateBricksSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.SandstoneSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.RedSandstoneSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.BrickBlockSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.MudBricksSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.TuffBricksSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.OakPlanksSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.BirchPlanksSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.JunglePlanksSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.SakuraPlanksSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.SprucePlanksSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.MangrovePlanksSlab.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.StoneWall.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.CobblestoneWall.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.MossyCobblestoneWall.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.StoneBricksWall.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.AndesiteWall.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.GraniteWall.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.DioriteWall.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.TuffWall.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.BasaltWall.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.BlackstoneWall.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.PolishedAndesiteWall.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.PolishedGraniteWall.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.PolishedDioriteWall.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.PolishedTuffWall.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.PolishedBasaltWall.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.DeepslateWall.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.CobbledDeepslateWall.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.DeepslateBricksWall.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.SandstoneWall.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.RedSandstoneWall.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.BrickBlockWall.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.MudBricksWall.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.TuffBricksWall.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.OakFence.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.BirchFence.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.JungleFence.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.SakuraFence.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.AcaciaFence.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.SpruceFence.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.DarkOakFence.spawnsWithFluid(), "!spawnsWithFluid"); + assertFalse(ObjectTypes.MangroveFence.spawnsWithFluid(), "!spawnsWithFluid"); assertFalse(ObjectTypes.WoodenPick.spawnsWithFluid(), "!spawnsWithFluid"); assertFalse(ObjectTypes.CopperPick.spawnsWithFluid(), "!spawnsWithFluid"); assertFalse(ObjectTypes.IronPick.spawnsWithFluid(), "!spawnsWithFluid"); @@ -9312,6 +12576,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Brick.isWaterloggable(), "!isWaterloggable"); assertFalse(ObjectTypes.Paper.isWaterloggable(), "!isWaterloggable"); assertFalse(ObjectTypes.Stick.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.StoneStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.CobblestoneStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.StoneBricksStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.SmoothStoneStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.AndesiteStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.GraniteStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.DioriteStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.TuffStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.BasaltStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.BlackstoneStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.PolishedTuffStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.DeepslateStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.SandstoneStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.RedSandstoneStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.BrickBlockStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.MudBricksStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.TuffBricksStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.OakPlanksStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.BirchPlanksStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.JunglePlanksStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.SprucePlanksStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.StoneSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.CobblestoneSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.StoneBricksSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.SmoothStoneSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.AndesiteSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.GraniteSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.DioriteSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.TuffSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.BasaltSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.BlackstoneSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.PolishedTuffSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.DeepslateSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.SandstoneSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.RedSandstoneSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.BrickBlockSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.MudBricksSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.TuffBricksSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.OakPlanksSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.BirchPlanksSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.JunglePlanksSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.SprucePlanksSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.StoneWall.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.CobblestoneWall.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.StoneBricksWall.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.AndesiteWall.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.GraniteWall.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.DioriteWall.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.TuffWall.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.BasaltWall.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.BlackstoneWall.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.PolishedGraniteWall.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.PolishedDioriteWall.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.PolishedTuffWall.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.PolishedBasaltWall.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.DeepslateWall.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.DeepslateBricksWall.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.SandstoneWall.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.RedSandstoneWall.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.BrickBlockWall.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.MudBricksWall.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.TuffBricksWall.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.OakFence.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.BirchFence.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.JungleFence.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.SakuraFence.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.AcaciaFence.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.SpruceFence.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.DarkOakFence.isWaterloggable(), "!isWaterloggable"); + assertFalse(ObjectTypes.MangroveFence.isWaterloggable(), "!isWaterloggable"); assertFalse(ObjectTypes.WoodenPick.isWaterloggable(), "!isWaterloggable"); assertFalse(ObjectTypes.CopperPick.isWaterloggable(), "!isWaterloggable"); assertFalse(ObjectTypes.IronPick.isWaterloggable(), "!isWaterloggable"); @@ -9595,6 +12961,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.isPreferredSpawn(), "!isPreferredSpawn"); assertFalse(ObjectTypes.Stick.isPreferredSpawn(), "!isPreferredSpawn"); assertFalse(ObjectTypes.Lodestone.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.StoneStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.CobblestoneStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.StoneBricksStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.SmoothStoneStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.AndesiteStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.GraniteStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.DioriteStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.TuffStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.BasaltStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.BlackstoneStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.PolishedTuffStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.DeepslateStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.SandstoneStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.RedSandstoneStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.BrickBlockStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.MudBricksStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.TuffBricksStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.OakPlanksStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.BirchPlanksStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.JunglePlanksStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.SprucePlanksStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.StoneSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.CobblestoneSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.StoneBricksSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.SmoothStoneSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.AndesiteSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.GraniteSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.DioriteSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.TuffSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.BasaltSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.BlackstoneSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.PolishedTuffSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.DeepslateSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.SandstoneSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.RedSandstoneSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.BrickBlockSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.MudBricksSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.TuffBricksSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.OakPlanksSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.BirchPlanksSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.JunglePlanksSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.SprucePlanksSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.StoneWall.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.CobblestoneWall.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.StoneBricksWall.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.AndesiteWall.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.GraniteWall.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.DioriteWall.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.TuffWall.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.BasaltWall.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.BlackstoneWall.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.PolishedGraniteWall.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.PolishedDioriteWall.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.PolishedTuffWall.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.PolishedBasaltWall.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.DeepslateWall.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.DeepslateBricksWall.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.SandstoneWall.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.RedSandstoneWall.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.BrickBlockWall.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.MudBricksWall.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.TuffBricksWall.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.OakFence.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.BirchFence.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.JungleFence.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.SakuraFence.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.AcaciaFence.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.SpruceFence.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.DarkOakFence.isPreferredSpawn(), "!isPreferredSpawn"); + assertFalse(ObjectTypes.MangroveFence.isPreferredSpawn(), "!isPreferredSpawn"); assertFalse(ObjectTypes.WoodenPick.isPreferredSpawn(), "!isPreferredSpawn"); assertFalse(ObjectTypes.CopperPick.isPreferredSpawn(), "!isPreferredSpawn"); assertFalse(ObjectTypes.IronPick.isPreferredSpawn(), "!isPreferredSpawn"); @@ -9878,6 +13346,108 @@ contract ObjectTypeTest is DustTest { assertFalse(ObjectTypes.Paper.isBurnOnCraft(), "!isBurnOnCraft"); assertFalse(ObjectTypes.Stick.isBurnOnCraft(), "!isBurnOnCraft"); assertFalse(ObjectTypes.Lodestone.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.StoneStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.CobblestoneStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.MossyCobblestoneStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.StoneBricksStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.SmoothStoneStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.AndesiteStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.GraniteStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.DioriteStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.TuffStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.BasaltStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.BlackstoneStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.PolishedAndesiteStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.PolishedGraniteStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.PolishedDioriteStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.PolishedTuffStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.PolishedBasaltStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.PolishedBlackstoneStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.DeepslateStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.CobbledDeepslateStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.DeepslateBricksStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.SandstoneStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.RedSandstoneStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.SmoothSandstoneStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.SmoothRedSandstoneStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.BrickBlockStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.MudBricksStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.TuffBricksStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.OakPlanksStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.BirchPlanksStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.JunglePlanksStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.SakuraPlanksStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.AcaciaPlanksStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.SprucePlanksStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.DarkOakPlanksStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.MangrovePlanksStairs.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.StoneSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.CobblestoneSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.MossyCobblestoneSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.StoneBricksSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.SmoothStoneSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.AndesiteSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.GraniteSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.DioriteSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.TuffSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.BasaltSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.BlackstoneSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.PolishedAndesiteSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.PolishedGraniteSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.PolishedDioriteSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.PolishedTuffSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.PolishedBasaltSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.PolishedBlackstoneSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.DeepslateSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.CobbledDeepslateSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.DeepslateBricksSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.SandstoneSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.RedSandstoneSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.SmoothSandstoneSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.SmoothRedSandstoneSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.BrickBlockSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.MudBricksSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.TuffBricksSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.OakPlanksSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.BirchPlanksSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.JunglePlanksSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.SakuraPlanksSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.AcaciaPlanksSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.SprucePlanksSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.DarkOakPlanksSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.MangrovePlanksSlab.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.StoneWall.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.CobblestoneWall.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.MossyCobblestoneWall.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.StoneBricksWall.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.AndesiteWall.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.GraniteWall.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.DioriteWall.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.TuffWall.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.BasaltWall.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.BlackstoneWall.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.PolishedAndesiteWall.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.PolishedGraniteWall.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.PolishedDioriteWall.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.PolishedTuffWall.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.PolishedBasaltWall.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.PolishedBlackstoneWall.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.DeepslateWall.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.CobbledDeepslateWall.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.DeepslateBricksWall.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.SandstoneWall.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.RedSandstoneWall.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.BrickBlockWall.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.MudBricksWall.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.TuffBricksWall.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.OakFence.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.BirchFence.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.JungleFence.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.SakuraFence.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.AcaciaFence.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.SpruceFence.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.DarkOakFence.isBurnOnCraft(), "!isBurnOnCraft"); + assertFalse(ObjectTypes.MangroveFence.isBurnOnCraft(), "!isBurnOnCraft"); assertFalse(ObjectTypes.WoodenPick.isBurnOnCraft(), "!isBurnOnCraft"); assertFalse(ObjectTypes.CopperPick.isBurnOnCraft(), "!isBurnOnCraft"); assertFalse(ObjectTypes.IronPick.isBurnOnCraft(), "!isBurnOnCraft"); diff --git a/packages/world/ts/objects.ts b/packages/world/ts/objects.ts index b084e7f6..e8bda511 100644 --- a/packages/world/ts/objects.ts +++ b/packages/world/ts/objects.ts @@ -1,4 +1,8 @@ -import { getOrientation } from "./orientation"; +import { + CARDINAL_ORIENTATIONS, + SLAB_ORIENTATIONS, + STAIR_ORIENTATIONS, +} from "./orientation"; const MINUTES = 60n; @@ -529,7 +533,7 @@ export interface ObjectDefinition { // Used for tools plankAmount?: number; oreAmount?: ObjectAmount; - supportedOrientations?: number[]; + supportedOrientations?: readonly number[]; } export const objects: readonly ObjectDefinition[] = validateUniqueIds([ @@ -767,12 +771,7 @@ export const objects: readonly ObjectDefinition[] = validateUniqueIds([ name: "TextSign", id: 120, mass: 18000000000000000n, - supportedOrientations: [ - getOrientation("PositiveX"), - getOrientation("NegativeX"), - getOrientation("PositiveZ"), - getOrientation("NegativeZ"), - ], + supportedOrientations: CARDINAL_ORIENTATIONS, }, { name: "OakPlanks", id: 121, mass: 4500000000000000n }, { name: "BirchPlanks", id: 122, mass: 4500000000000000n }, @@ -860,76 +859,43 @@ export const objects: readonly ObjectDefinition[] = validateUniqueIds([ name: "ForceField", id: 145, mass: 1035000000000000000n, - supportedOrientations: [ - getOrientation("PositiveX"), - getOrientation("NegativeX"), - getOrientation("PositiveZ"), - getOrientation("NegativeZ"), - ], + supportedOrientations: CARDINAL_ORIENTATIONS, }, { name: "Chest", id: 146, mass: 36000000000000000n, - supportedOrientations: [ - getOrientation("PositiveX"), - getOrientation("NegativeX"), - getOrientation("PositiveZ"), - getOrientation("NegativeZ"), - ], + supportedOrientations: CARDINAL_ORIENTATIONS, }, { name: "SpawnTile", id: 147, mass: 6435000000000000000n, - supportedOrientations: [ - getOrientation("PositiveX"), - getOrientation("NegativeX"), - getOrientation("PositiveZ"), - getOrientation("NegativeZ"), - ], + supportedOrientations: CARDINAL_ORIENTATIONS, }, { name: "Bed", id: 148, mass: 13500000000000000n, - supportedOrientations: [ - getOrientation("NegativeX"), - getOrientation("NegativeZ"), - ], + supportedOrientations: [1, 44], // Only NegativeX and NegativeZ orientations }, { name: "Workbench", id: 149, mass: 18000000000000000n, - supportedOrientations: [ - getOrientation("PositiveX"), - getOrientation("NegativeX"), - getOrientation("PositiveZ"), - getOrientation("NegativeZ"), - ], + supportedOrientations: CARDINAL_ORIENTATIONS, }, { name: "Powerstone", id: 150, mass: 80000000000000000n, - supportedOrientations: [ - getOrientation("PositiveX"), - getOrientation("NegativeX"), - getOrientation("PositiveZ"), - getOrientation("NegativeZ"), - ], + supportedOrientations: CARDINAL_ORIENTATIONS, }, { name: "Furnace", id: 151, mass: 108000000000000000n, - supportedOrientations: [ - getOrientation("PositiveX"), - getOrientation("NegativeX"), - getOrientation("PositiveZ"), - getOrientation("NegativeZ"), - ], + supportedOrientations: CARDINAL_ORIENTATIONS, }, { name: "Torch", id: 152, mass: 1125000000000000n }, { name: "GreenTerracotta", id: 153, mass: 37500000000000000n }, @@ -941,12 +907,7 @@ export const objects: readonly ObjectDefinition[] = validateUniqueIds([ name: "Stonecutter", id: 256, mass: 711000000000000000n, - supportedOrientations: [ - getOrientation("PositiveX"), - getOrientation("NegativeX"), - getOrientation("PositiveZ"), - getOrientation("NegativeZ"), - ], + supportedOrientations: CARDINAL_ORIENTATIONS, }, { name: "StoneBricks", id: 257, mass: 12000000000000000n }, @@ -1103,118 +1064,468 @@ export const objects: readonly ObjectDefinition[] = validateUniqueIds([ { name: "Lodestone", id: 389, mass: 771000000000000000n }, // { name: "FlowerPot", id: 390, mass: 7200000000000000n }, - // { name: "Barrel", id: 375, mass: 31500000000000000n }, - // { name: "Ladder", id: 376, mass: 5250000000000000n }, - // { name: "Lantern", id: 377, mass: 676125000000000000n }, - // { name: "Carpet", id: 378, mass: 200000000000000n }, - // { name: "Book", id: 379, mass: 900000000000000n }, - // { name: "Bookshelf", id: 380, mass: 29700000000000000n }, - // { name: "IronBars", id: 381, mass: 253125000000000000n }, + // { name: "Barrel", id: 391, mass: 31500000000000000n }, + // { name: "Ladder", id: 392, mass: 5250000000000000n }, + // { name: "Lantern", id: 393, mass: 676125000000000000n }, + // { name: "Carpet", id: 394, mass: 200000000000000n }, + // { name: "Book", id: 395, mass: 900000000000000n }, + // { name: "Bookshelf", id: 396, mass: 29700000000000000n }, + // { name: "IronBars", id: 397, mass: 253125000000000000n }, // Shape variants - Stairs (same mass as base material) - // { name: "StoneStairs", id: 382, mass: 12000000000000000n }, - // { name: "CobblestoneStairs", id: 383, mass: 22500000000000000n }, - // { name: "MossyCobblestoneStairs", id: 384, mass: 37500000000000000n }, - // { name: "StoneBricksStairs", id: 385, mass: 12000000000000000n }, - // { name: "SmoothStoneStairs", id: 386, mass: 12000000000000000n }, - // { name: "AndesiteStairs", id: 387, mass: 15000000000000000n }, - // { name: "GraniteStairs", id: 388, mass: 15000000000000000n }, - // { name: "DioriteStairs", id: 389, mass: 18000000000000000n }, - // { name: "TuffStairs", id: 390, mass: 15000000000000000n }, - // { name: "BasaltStairs", id: 391, mass: 75000000000000000n }, - // { name: "BlackstoneStairs", id: 392, mass: 50000000000000000n }, - // { name: "PolishedAndesiteStairs", id: 393, mass: 15000000000000000n }, - // { name: "PolishedGraniteStairs", id: 394, mass: 15000000000000000n }, - // { name: "PolishedDioriteStairs", id: 395, mass: 18000000000000000n }, - // { name: "PolishedTuffStairs", id: 396, mass: 15000000000000000n }, - // { name: "PolishedBasaltStairs", id: 397, mass: 75000000000000000n }, - // { name: "PolishedBlackstoneStairs", id: 398, mass: 50000000000000000n }, - // { name: "DeepslateStairs", id: 399, mass: 40000000000000000n }, - // { name: "CobbledDeepslateStairs", id: 400, mass: 100000000000000000n }, - // { name: "DeepslateBricksStairs", id: 401, mass: 100000000000000000n }, - // { name: "SandstoneStairs", id: 402, mass: 30000000000000000n }, - // { name: "RedSandstoneStairs", id: 403, mass: 37500000000000000n }, - // { name: "SmoothSandstoneStairs", id: 404, mass: 30000000000000000n }, - // { name: "SmoothRedSandstoneStairs", id: 405, mass: 37500000000000000n }, - // { name: "BrickBlockStairs", id: 406, mass: 9600000000000000n }, - // { name: "MudBricksStairs", id: 407, mass: 5000000000000000n }, - // { name: "TuffBricksStairs", id: 408, mass: 15000000000000000n }, - // { name: "OakPlanksStairs", id: 409, mass: 4500000000000000n }, - // { name: "BirchPlanksStairs", id: 410, mass: 4500000000000000n }, - // { name: "JunglePlanksStairs", id: 411, mass: 4500000000000000n }, - // { name: "SakuraPlanksStairs", id: 412, mass: 4500000000000000n }, - // { name: "AcaciaPlanksStairs", id: 413, mass: 4500000000000000n }, - // { name: "SprucePlanksStairs", id: 414, mass: 4500000000000000n }, - // { name: "DarkOakPlanksStairs", id: 415, mass: 4500000000000000n }, - // { name: "MangrovePlanksStairs", id: 416, mass: 4500000000000000n }, + { + name: "StoneStairs", + id: 398, + mass: 12000000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "CobblestoneStairs", + id: 399, + mass: 22500000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "MossyCobblestoneStairs", + id: 400, + mass: 37500000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "StoneBricksStairs", + id: 401, + mass: 12000000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "SmoothStoneStairs", + id: 402, + mass: 12000000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "AndesiteStairs", + id: 403, + mass: 15000000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "GraniteStairs", + id: 404, + mass: 15000000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "DioriteStairs", + id: 405, + mass: 18000000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "TuffStairs", + id: 406, + mass: 15000000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "BasaltStairs", + id: 407, + mass: 75000000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "BlackstoneStairs", + id: 408, + mass: 50000000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "PolishedAndesiteStairs", + id: 409, + mass: 15000000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "PolishedGraniteStairs", + id: 410, + mass: 15000000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "PolishedDioriteStairs", + id: 411, + mass: 18000000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "PolishedTuffStairs", + id: 412, + mass: 15000000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "PolishedBasaltStairs", + id: 413, + mass: 75000000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "PolishedBlackstoneStairs", + id: 414, + mass: 50000000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "DeepslateStairs", + id: 415, + mass: 40000000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "CobbledDeepslateStairs", + id: 416, + mass: 100000000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "DeepslateBricksStairs", + id: 417, + mass: 100000000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "SandstoneStairs", + id: 418, + mass: 30000000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "RedSandstoneStairs", + id: 419, + mass: 37500000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "SmoothSandstoneStairs", + id: 420, + mass: 30000000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "SmoothRedSandstoneStairs", + id: 421, + mass: 37500000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "BrickBlockStairs", + id: 422, + mass: 9600000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "MudBricksStairs", + id: 423, + mass: 5000000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "TuffBricksStairs", + id: 424, + mass: 15000000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "OakPlanksStairs", + id: 425, + mass: 4500000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "BirchPlanksStairs", + id: 426, + mass: 4500000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "JunglePlanksStairs", + id: 427, + mass: 4500000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "SakuraPlanksStairs", + id: 428, + mass: 4500000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "AcaciaPlanksStairs", + id: 429, + mass: 4500000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "SprucePlanksStairs", + id: 430, + mass: 4500000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "DarkOakPlanksStairs", + id: 431, + mass: 4500000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, + { + name: "MangrovePlanksStairs", + id: 432, + mass: 4500000000000000n, + supportedOrientations: STAIR_ORIENTATIONS, + }, // Shape variants - Slabs (half mass of base material) - // { name: "StoneSlab", id: 417, mass: 6000000000000000n }, - // { name: "CobblestoneSlab", id: 418, mass: 11250000000000000n }, - // { name: "MossyCobblestoneSlab", id: 419, mass: 18750000000000000n }, - // { name: "StoneBricksSlab", id: 420, mass: 6000000000000000n }, - // { name: "SmoothStoneSlab", id: 421, mass: 6000000000000000n }, - // { name: "AndesiteSlab", id: 422, mass: 7500000000000000n }, - // { name: "GraniteSlab", id: 423, mass: 7500000000000000n }, - // { name: "DioriteSlab", id: 424, mass: 9000000000000000n }, - // { name: "TuffSlab", id: 425, mass: 7500000000000000n }, - // { name: "BasaltSlab", id: 426, mass: 37500000000000000n }, - // { name: "BlackstoneSlab", id: 427, mass: 25000000000000000n }, - // { name: "PolishedAndesiteSlab", id: 428, mass: 7500000000000000n }, - // { name: "PolishedGraniteSlab", id: 429, mass: 7500000000000000n }, - // { name: "PolishedDioriteSlab", id: 430, mass: 9000000000000000n }, - // { name: "PolishedTuffSlab", id: 431, mass: 7500000000000000n }, - // { name: "PolishedBasaltSlab", id: 432, mass: 37500000000000000n }, - // { name: "PolishedBlackstoneSlab", id: 433, mass: 25000000000000000n }, - // { name: "DeepslateSlab", id: 434, mass: 20000000000000000n }, - // { name: "CobbledDeepslateSlab", id: 435, mass: 50000000000000000n }, - // { name: "DeepslateBricksSlab", id: 436, mass: 50000000000000000n }, - // { name: "SandstoneSlab", id: 437, mass: 15000000000000000n }, - // { name: "RedSandstoneSlab", id: 438, mass: 18750000000000000n }, - // { name: "SmoothSandstoneSlab", id: 439, mass: 15000000000000000n }, - // { name: "SmoothRedSandstoneSlab", id: 440, mass: 18750000000000000n }, - // { name: "BrickBlockSlab", id: 441, mass: 4800000000000000n }, - // { name: "MudBricksSlab", id: 442, mass: 2500000000000000n }, - // { name: "TuffBricksSlab", id: 443, mass: 7500000000000000n }, - // { name: "OakPlanksSlab", id: 444, mass: 2250000000000000n }, - // { name: "BirchPlanksSlab", id: 445, mass: 2250000000000000n }, - // { name: "JunglePlanksSlab", id: 446, mass: 2250000000000000n }, - // { name: "SakuraPlanksSlab", id: 447, mass: 2250000000000000n }, - // { name: "AcaciaPlanksSlab", id: 448, mass: 2250000000000000n }, - // { name: "SprucePlanksSlab", id: 449, mass: 2250000000000000n }, - // { name: "DarkOakPlanksSlab", id: 450, mass: 2250000000000000n }, - // { name: "MangrovePlanksSlab", id: 451, mass: 2250000000000000n }, + { + name: "StoneSlab", + id: 433, + mass: 6000000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "CobblestoneSlab", + id: 434, + mass: 11250000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "MossyCobblestoneSlab", + id: 435, + mass: 18750000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "StoneBricksSlab", + id: 436, + mass: 6000000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "SmoothStoneSlab", + id: 437, + mass: 6000000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "AndesiteSlab", + id: 438, + mass: 7500000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "GraniteSlab", + id: 439, + mass: 7500000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "DioriteSlab", + id: 440, + mass: 9000000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "TuffSlab", + id: 441, + mass: 7500000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "BasaltSlab", + id: 442, + mass: 37500000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "BlackstoneSlab", + id: 443, + mass: 25000000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "PolishedAndesiteSlab", + id: 444, + mass: 7500000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "PolishedGraniteSlab", + id: 445, + mass: 7500000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "PolishedDioriteSlab", + id: 446, + mass: 9000000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "PolishedTuffSlab", + id: 447, + mass: 7500000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "PolishedBasaltSlab", + id: 448, + mass: 37500000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "PolishedBlackstoneSlab", + id: 449, + mass: 25000000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "DeepslateSlab", + id: 450, + mass: 20000000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "CobbledDeepslateSlab", + id: 451, + mass: 50000000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "DeepslateBricksSlab", + id: 452, + mass: 50000000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "SandstoneSlab", + id: 453, + mass: 15000000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "RedSandstoneSlab", + id: 454, + mass: 18750000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "SmoothSandstoneSlab", + id: 455, + mass: 15000000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "SmoothRedSandstoneSlab", + id: 456, + mass: 18750000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "BrickBlockSlab", + id: 457, + mass: 4800000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "MudBricksSlab", + id: 458, + mass: 2500000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "TuffBricksSlab", + id: 459, + mass: 7500000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "OakPlanksSlab", + id: 460, + mass: 2250000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "BirchPlanksSlab", + id: 461, + mass: 2250000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "JunglePlanksSlab", + id: 462, + mass: 2250000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "SakuraPlanksSlab", + id: 463, + mass: 2250000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "AcaciaPlanksSlab", + id: 464, + mass: 2250000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "SprucePlanksSlab", + id: 465, + mass: 2250000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "DarkOakPlanksSlab", + id: 466, + mass: 2250000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, + { + name: "MangrovePlanksSlab", + id: 467, + mass: 2250000000000000n, + supportedOrientations: SLAB_ORIENTATIONS, + }, // Shape variants - Walls (same mass as base material) - // { name: "StoneWall", id: 452, mass: 12000000000000000n }, - // { name: "CobblestoneWall", id: 453, mass: 22500000000000000n }, - // { name: "MossyCobblestoneWall", id: 454, mass: 37500000000000000n }, - // { name: "StoneBricksWall", id: 455, mass: 12000000000000000n }, - // { name: "AndesiteWall", id: 456, mass: 15000000000000000n }, - // { name: "GraniteWall", id: 457, mass: 15000000000000000n }, - // { name: "DioriteWall", id: 458, mass: 18000000000000000n }, - // { name: "TuffWall", id: 459, mass: 15000000000000000n }, - // { name: "BasaltWall", id: 460, mass: 75000000000000000n }, - // { name: "BlackstoneWall", id: 461, mass: 50000000000000000n }, - // { name: "PolishedAndesiteWall", id: 462, mass: 15000000000000000n }, - // { name: "PolishedGraniteWall", id: 463, mass: 15000000000000000n }, - // { name: "PolishedDioriteWall", id: 464, mass: 18000000000000000n }, - // { name: "PolishedTuffWall", id: 465, mass: 15000000000000000n }, - // { name: "PolishedBasaltWall", id: 466, mass: 75000000000000000n }, - // { name: "PolishedBlackstoneWall", id: 467, mass: 50000000000000000n }, - // { name: "DeepslateWall", id: 468, mass: 40000000000000000n }, - // { name: "CobbledDeepslateWall", id: 469, mass: 100000000000000000n }, - // { name: "DeepslateBricksWall", id: 470, mass: 100000000000000000n }, - // { name: "SandstoneWall", id: 471, mass: 30000000000000000n }, - // { name: "RedSandstoneWall", id: 472, mass: 37500000000000000n }, - // { name: "BrickBlockWall", id: 473, mass: 9600000000000000n }, - // { name: "MudBricksWall", id: 474, mass: 5000000000000000n }, - // { name: "TuffBricksWall", id: 475, mass: 15000000000000000n }, + { name: "StoneWall", id: 468, mass: 12000000000000000n }, + { name: "CobblestoneWall", id: 469, mass: 22500000000000000n }, + { name: "MossyCobblestoneWall", id: 470, mass: 37500000000000000n }, + { name: "StoneBricksWall", id: 471, mass: 12000000000000000n }, + { name: "AndesiteWall", id: 472, mass: 15000000000000000n }, + { name: "GraniteWall", id: 473, mass: 15000000000000000n }, + { name: "DioriteWall", id: 474, mass: 18000000000000000n }, + { name: "TuffWall", id: 475, mass: 15000000000000000n }, + { name: "BasaltWall", id: 476, mass: 75000000000000000n }, + { name: "BlackstoneWall", id: 477, mass: 50000000000000000n }, + { name: "PolishedAndesiteWall", id: 478, mass: 15000000000000000n }, + { name: "PolishedGraniteWall", id: 479, mass: 15000000000000000n }, + { name: "PolishedDioriteWall", id: 480, mass: 18000000000000000n }, + { name: "PolishedTuffWall", id: 481, mass: 15000000000000000n }, + { name: "PolishedBasaltWall", id: 482, mass: 75000000000000000n }, + { name: "PolishedBlackstoneWall", id: 483, mass: 50000000000000000n }, + { name: "DeepslateWall", id: 484, mass: 40000000000000000n }, + { name: "CobbledDeepslateWall", id: 485, mass: 100000000000000000n }, + { name: "DeepslateBricksWall", id: 486, mass: 100000000000000000n }, + { name: "SandstoneWall", id: 487, mass: 30000000000000000n }, + { name: "RedSandstoneWall", id: 488, mass: 37500000000000000n }, + { name: "BrickBlockWall", id: 489, mass: 9600000000000000n }, + { name: "MudBricksWall", id: 490, mass: 5000000000000000n }, + { name: "TuffBricksWall", id: 491, mass: 15000000000000000n }, // Functional objects // { // name: "OakDoor", - // id: 476, + // id: 492, // mass: 9000000000000000n, // supportedOrientations: [ // getOrientation("PositiveX"), @@ -1223,16 +1534,16 @@ export const objects: readonly ObjectDefinition[] = validateUniqueIds([ // getOrientation("NegativeZ"), // ], // }, - // { name: "BirchDoor", id: 477, mass: 9000000000000000n }, - // { name: "JungleDoor", id: 478, mass: 9000000000000000n }, - // { name: "SakuraDoor", id: 479, mass: 9000000000000000n }, - // { name: "AcaciaDoor", id: 480, mass: 9000000000000000n }, - // { name: "SpruceDoor", id: 481, mass: 9000000000000000n }, - // { name: "DarkOakDoor", id: 482, mass: 9000000000000000n }, - // { name: "MangroveDoor", id: 483, mass: 9000000000000000n }, + // { name: "BirchDoor", id: 493, mass: 9000000000000000n }, + // { name: "JungleDoor", id: 494, mass: 9000000000000000n }, + // { name: "SakuraDoor", id: 495, mass: 9000000000000000n }, + // { name: "AcaciaDoor", id: 496, mass: 9000000000000000n }, + // { name: "SpruceDoor", id: 497, mass: 9000000000000000n }, + // { name: "DarkOakDoor", id: 498, mass: 9000000000000000n }, + // { name: "MangroveDoor", id: 499, mass: 9000000000000000n }, // { // name: "IronDoor", - // id: 484, + // id: 500, // mass: 1350000000000000000n, // supportedOrientations: [ // getOrientation("PositiveX"), @@ -1243,35 +1554,35 @@ export const objects: readonly ObjectDefinition[] = validateUniqueIds([ // }, // Trapdoors - // { name: "OakTrapdoor", id: 485, mass: 13500000000000000n }, - // { name: "BirchTrapdoor", id: 486, mass: 13500000000000000n }, - // { name: "JungleTrapdoor", id: 487, mass: 13500000000000000n }, - // { name: "SakuraTrapdoor", id: 488, mass: 13500000000000000n }, - // { name: "AcaciaTrapdoor", id: 489, mass: 13500000000000000n }, - // { name: "SpruceTrapdoor", id: 490, mass: 13500000000000000n }, - // { name: "DarkOakTrapdoor", id: 491, mass: 13500000000000000n }, - // { name: "MangroveTrapdoor", id: 492, mass: 13500000000000000n }, - // { name: "IronTrapdoor", id: 493, mass: 2700000000000000000n }, + // { name: "OakTrapdoor", id: 501, mass: 13500000000000000n }, + // { name: "BirchTrapdoor", id: 502, mass: 13500000000000000n }, + // { name: "JungleTrapdoor", id: 503, mass: 13500000000000000n }, + // { name: "SakuraTrapdoor", id: 504, mass: 13500000000000000n }, + // { name: "AcaciaTrapdoor", id: 505, mass: 13500000000000000n }, + // { name: "SpruceTrapdoor", id: 506, mass: 13500000000000000n }, + // { name: "DarkOakTrapdoor", id: 507, mass: 13500000000000000n }, + // { name: "MangroveTrapdoor", id: 508, mass: 13500000000000000n }, + // { name: "IronTrapdoor", id: 509, mass: 2700000000000000000n }, // Fences - // { name: "OakFence", id: 494, mass: 7500000000000000n }, - // { name: "BirchFence", id: 495, mass: 7500000000000000n }, - // { name: "JungleFence", id: 496, mass: 7500000000000000n }, - // { name: "SakuraFence", id: 497, mass: 7500000000000000n }, - // { name: "AcaciaFence", id: 498, mass: 7500000000000000n }, - // { name: "SpruceFence", id: 499, mass: 7500000000000000n }, - // { name: "DarkOakFence", id: 500, mass: 7500000000000000n }, - // { name: "MangroveFence", id: 501, mass: 7500000000000000n }, + { name: "OakFence", id: 510, mass: 7500000000000000n }, + { name: "BirchFence", id: 511, mass: 7500000000000000n }, + { name: "JungleFence", id: 512, mass: 7500000000000000n }, + { name: "SakuraFence", id: 513, mass: 7500000000000000n }, + { name: "AcaciaFence", id: 514, mass: 7500000000000000n }, + { name: "SpruceFence", id: 515, mass: 7500000000000000n }, + { name: "DarkOakFence", id: 516, mass: 7500000000000000n }, + { name: "MangroveFence", id: 517, mass: 7500000000000000n }, // Gates - // { name: "OakFenceGate", id: 502, mass: 18000000000000000n }, - // { name: "BirchFenceGate", id: 503, mass: 18000000000000000n }, - // { name: "JungleFenceGate", id: 504, mass: 18000000000000000n }, - // { name: "SakuraFenceGate", id: 505, mass: 18000000000000000n }, - // { name: "AcaciaFenceGate", id: 506, mass: 18000000000000000n }, - // { name: "SpruceFenceGate", id: 507, mass: 18000000000000000n }, - // { name: "DarkOakFenceGate", id: 508, mass: 18000000000000000n }, - // { name: "MangroveFenceGate", id: 509, mass: 18000000000000000n }, + // { name: "OakFenceGate", id: 518, mass: 18000000000000000n }, + // { name: "BirchFenceGate", id: 519, mass: 18000000000000000n }, + // { name: "JungleFenceGate", id: 520, mass: 18000000000000000n }, + // { name: "SakuraFenceGate", id: 521, mass: 18000000000000000n }, + // { name: "AcaciaFenceGate", id: 522, mass: 18000000000000000n }, + // { name: "SpruceFenceGate", id: 523, mass: 18000000000000000n }, + // { name: "DarkOakFenceGate", id: 524, mass: 18000000000000000n }, + // { name: "MangroveFenceGate", id: 525, mass: 18000000000000000n }, // Non blocks { name: "WoodenPick", id: 32768, mass: 22500000000000000n, plankAmount: 5 }, @@ -1664,6 +1975,147 @@ export const categories = { "GreenConcrete", "RedConcrete", "BlackConcrete", + // Stairs + "StoneStairs", + "CobblestoneStairs", + "MossyCobblestoneStairs", + "StoneBricksStairs", + "SmoothStoneStairs", + "AndesiteStairs", + "GraniteStairs", + "DioriteStairs", + "TuffStairs", + "BasaltStairs", + "BlackstoneStairs", + "PolishedAndesiteStairs", + "PolishedGraniteStairs", + "PolishedDioriteStairs", + "PolishedTuffStairs", + "PolishedBasaltStairs", + "PolishedBlackstoneStairs", + "DeepslateStairs", + "CobbledDeepslateStairs", + "DeepslateBricksStairs", + "SandstoneStairs", + "RedSandstoneStairs", + "SmoothSandstoneStairs", + "SmoothRedSandstoneStairs", + "BrickBlockStairs", + "MudBricksStairs", + "TuffBricksStairs", + "OakPlanksStairs", + "BirchPlanksStairs", + "JunglePlanksStairs", + "SakuraPlanksStairs", + "AcaciaPlanksStairs", + "SprucePlanksStairs", + "DarkOakPlanksStairs", + "MangrovePlanksStairs", + + // Slabs + "StoneSlab", + "CobblestoneSlab", + "MossyCobblestoneSlab", + "StoneBricksSlab", + "SmoothStoneSlab", + "AndesiteSlab", + "GraniteSlab", + "DioriteSlab", + "TuffSlab", + "BasaltSlab", + "BlackstoneSlab", + "PolishedAndesiteSlab", + "PolishedGraniteSlab", + "PolishedDioriteSlab", + "PolishedTuffSlab", + "PolishedBasaltSlab", + "PolishedBlackstoneSlab", + "DeepslateSlab", + "CobbledDeepslateSlab", + "DeepslateBricksSlab", + "SandstoneSlab", + "RedSandstoneSlab", + "SmoothSandstoneSlab", + "SmoothRedSandstoneSlab", + "BrickBlockSlab", + "MudBricksSlab", + "TuffBricksSlab", + "OakPlanksSlab", + "BirchPlanksSlab", + "JunglePlanksSlab", + "SakuraPlanksSlab", + "AcaciaPlanksSlab", + "SprucePlanksSlab", + "DarkOakPlanksSlab", + "MangrovePlanksSlab", + + // Walls + "StoneWall", + "CobblestoneWall", + "MossyCobblestoneWall", + "StoneBricksWall", + "AndesiteWall", + "GraniteWall", + "DioriteWall", + "TuffWall", + "BasaltWall", + "BlackstoneWall", + "PolishedAndesiteWall", + "PolishedGraniteWall", + "PolishedDioriteWall", + "PolishedTuffWall", + "PolishedBasaltWall", + "PolishedBlackstoneWall", + "DeepslateWall", + "CobbledDeepslateWall", + "DeepslateBricksWall", + "SandstoneWall", + "RedSandstoneWall", + "BrickBlockWall", + "MudBricksWall", + "TuffBricksWall", + + // Doors + // "OakDoor", + // "BirchDoor", + // "JungleDoor", + // "SakuraDoor", + // "AcaciaDoor", + // "SpruceDoor", + // "DarkOakDoor", + // "MangroveDoor", + // "IronDoor", + + // Trapdoors + // "OakTrapdoor", + // "BirchTrapdoor", + // "JungleTrapdoor", + // "SakuraTrapdoor", + // "AcaciaTrapdoor", + // "SpruceTrapdoor", + // "DarkOakTrapdoor", + // "MangroveTrapdoor", + // "IronTrapdoor", + + // Fences + "OakFence", + "BirchFence", + "JungleFence", + "SakuraFence", + "AcaciaFence", + "SpruceFence", + "DarkOakFence", + "MangroveFence", + + // Gates + // "OakFenceGate", + // "BirchFenceGate", + // "JungleFenceGate", + // "SakuraFenceGate", + // "AcaciaFenceGate", + // "SpruceFenceGate", + // "DarkOakFenceGate", + // "MangroveFenceGate", ], }, Terracotta: { diff --git a/packages/world/ts/orientation.ts b/packages/world/ts/orientation.ts index 704e9ead..298b3f07 100644 --- a/packages/world/ts/orientation.ts +++ b/packages/world/ts/orientation.ts @@ -4,20 +4,63 @@ import type { Vec3 } from "./vec3"; // Direction is an array of strings config.enums.Direction; -type Direction = (typeof config.enums.Direction)[number]; +export type Direction = (typeof config.enums.Direction)[number]; -const SUPPORTED_DIRECTION_VECTORS: { - [key in Direction]?: [number, number, number]; -} = { +export const CANONICAL_VECTORS = { PositiveX: [1, 0, 0], NegativeX: [-1, 0, 0], PositiveY: [0, 1, 0], NegativeY: [0, -1, 0], PositiveZ: [0, 0, 1], NegativeZ: [0, 0, -1], -}; - -type SupportedDirection = keyof typeof SUPPORTED_DIRECTION_VECTORS; + PositiveXPositiveY: [1, 1, 0], + PositiveXNegativeY: [1, -1, 0], + NegativeXPositiveY: [-1, 1, 0], + NegativeXNegativeY: [-1, -1, 0], + PositiveXPositiveZ: [1, 0, 1], + PositiveXNegativeZ: [1, 0, -1], + NegativeXPositiveZ: [-1, 0, 1], + NegativeXNegativeZ: [-1, 0, -1], + PositiveYPositiveZ: [0, 1, 1], + PositiveYNegativeZ: [0, 1, -1], + NegativeYPositiveZ: [0, -1, 1], + NegativeYNegativeZ: [0, -1, -1], + PositiveXPositiveYPositiveZ: [1, 1, 1], + PositiveXPositiveYNegativeZ: [1, 1, -1], + PositiveXNegativeYPositiveZ: [1, -1, 1], + PositiveXNegativeYNegativeZ: [1, -1, -1], + NegativeXPositiveYPositiveZ: [-1, 1, 1], + NegativeXPositiveYNegativeZ: [-1, 1, -1], + NegativeXNegativeYPositiveZ: [-1, -1, 1], + NegativeXNegativeYNegativeZ: [-1, -1, -1], +} as const satisfies { [key in Direction]: Vec3 }; + +export const CANONICAL_UP: Vec3 = CANONICAL_VECTORS.PositiveY; +export const CANONICAL_FORWARD: Vec3 = CANONICAL_VECTORS.PositiveX; + +// Full six axis directions (for general use, e.g., forward or up in orientations) +export type AxisDirection = + | "PositiveX" + | "NegativeX" + | "PositiveY" + | "NegativeY" + | "PositiveZ" + | "NegativeZ"; + +// Narrowed to four horizontal cardinals (for facing/forward in placement) +export type CardinalDirection = + | "PositiveX" + | "NegativeX" + | "PositiveZ" + | "NegativeZ"; + +export type SupportedDirection = + | "PositiveX" + | "NegativeX" + | "PositiveY" + | "NegativeY" + | "PositiveZ" + | "NegativeZ"; export type Orientation = number; // uint8 in Solidity @@ -63,9 +106,6 @@ export const REFLECTIONS: readonly [ [1, 1, 1], // Reflect all axes ] as const; -const CANONICAL_UP: Vec3 = [0, 1, 0]; -const CANONICAL_FORWARD: Vec3 = [1, 0, 0]; - export function applyOrientation(v: Vec3, perm: Permute, refl: Reflect): Vec3 { const out: Vec3 = [v[perm[0]]!, v[perm[1]]!, v[perm[2]]!]; if (refl[0]) out[0] = -out[0]; @@ -74,18 +114,16 @@ export function applyOrientation(v: Vec3, perm: Permute, refl: Reflect): Vec3 { return out; } -export function getOrientation( - forwardDirection: SupportedDirection, -): Orientation { +export function getOrientation(forwardDirection: AxisDirection): Orientation { return getOrientationGeneric(forwardDirection, "PositiveY"); } export function getOrientationGeneric( - forwardDirection: SupportedDirection, - upDirection: SupportedDirection, + forwardDirection: AxisDirection, + upDirection: AxisDirection, ): Orientation { - const targetForward = SUPPORTED_DIRECTION_VECTORS[forwardDirection]!; - const targetUp = SUPPORTED_DIRECTION_VECTORS[upDirection]!; + const targetForward = CANONICAL_VECTORS[forwardDirection]!; + const targetUp = CANONICAL_VECTORS[upDirection]!; for (let permIdx = 0; permIdx < PERMUTATIONS.length; ++permIdx) { for (let reflIdx = 0; reflIdx < REFLECTIONS.length; ++reflIdx) { @@ -116,28 +154,25 @@ export function getDirection(orientation: Orientation): SupportedDirection { export function getDirectionGeneric( orientation: Orientation, - upDirection: SupportedDirection, -): SupportedDirection { + upDirection: AxisDirection, +): AxisDirection { const [perm, refl] = decodeOrientation(orientation); const up = applyOrientation(CANONICAL_UP, perm, refl); - const targetUp = SUPPORTED_DIRECTION_VECTORS[upDirection]!; + const targetUp = CANONICAL_VECTORS[upDirection]!; const forward = applyOrientation(CANONICAL_FORWARD, perm, refl); - const forwardDirection = Object.keys(SUPPORTED_DIRECTION_VECTORS).find( - (dir) => { - const targetForward = - SUPPORTED_DIRECTION_VECTORS[dir as SupportedDirection]!; - return ( - up[0] === targetUp[0] && - up[1] === targetUp[1] && - up[2] === targetUp[2] && - forward[0] === targetForward[0] && - forward[1] === targetForward[1] && - forward[2] === targetForward[2] - ); - }, - ); + const forwardDirection = Object.keys(CANONICAL_VECTORS).find((dir) => { + const targetForward = CANONICAL_VECTORS[dir as SupportedDirection]!; + return ( + up[0] === targetUp[0] && + up[1] === targetUp[1] && + up[2] === targetUp[2] && + forward[0] === targetForward[0] && + forward[1] === targetForward[1] && + forward[2] === targetForward[2] + ); + }); if (!forwardDirection) throw new Error("Unable to find direction"); return forwardDirection as SupportedDirection; } @@ -166,3 +201,29 @@ export function decodeOrientation( const reflIdx = orientation & 7; return [PERMUTATIONS[permIdx]!, REFLECTIONS[reflIdx]!]; } + +export function isUpsideDown(orientation: Orientation): boolean { + const [perm, refl] = decodeOrientation(orientation); + const up = applyOrientation(CANONICAL_UP, perm, refl); + return up[0] === 0 && up[1] === -1 && up[2] === 0; +} + +// All possible orientations (0-47) +export const ALL_ORIENTATIONS: readonly Orientation[] = Array.from( + { length: 48 }, + (_, i) => i, +); + +// Common orientation sets for different object types +export const CARDINAL_ORIENTATIONS: readonly Orientation[] = [0, 1, 40, 44]; +export const STAIR_ORIENTATIONS: readonly Orientation[] = [ + 0, + 1, + 40, + 44, + 2, + 3, + 42, + 46, // 8 orientations for stairs (4 directions × 2 for upside-down) +]; +export const SLAB_ORIENTATIONS: readonly Orientation[] = [0, 2]; // Bottom and top slabs diff --git a/packages/world/ts/recipes.ts b/packages/world/ts/recipes.ts index ac16107e..0130d428 100644 --- a/packages/world/ts/recipes.ts +++ b/packages/world/ts/recipes.ts @@ -854,6 +854,7 @@ export const recipes: Recipe[] = [ inputs: [["Blackstone", 1]], outputs: [["PolishedBlackstone", 1]], }, + // Chiseled blocks (Stonecutter) { station: "Stonecutter", @@ -1440,62 +1441,66 @@ export const recipes: Recipe[] = [ // inputs: [["IronBar", 4]], // outputs: [["IronTrapdoor", 1]], // }, - // { - // inputs: [ - // ["OakPlanks", 4], - // ["Stick", 2], - // ], - // outputs: [["OakFence", 3]], - // }, - // { - // inputs: [ - // ["BirchPlanks", 4], - // ["Stick", 2], - // ], - // outputs: [["BirchFence", 3]], - // }, - // { - // inputs: [ - // ["JunglePlanks", 4], - // ["Stick", 2], - // ], - // outputs: [["JungleFence", 3]], - // }, - // { - // inputs: [ - // ["SakuraPlanks", 4], - // ["Stick", 2], - // ], - // outputs: [["SakuraFence", 3]], - // }, - // { - // inputs: [ - // ["AcaciaPlanks", 4], - // ["Stick", 2], - // ], - // outputs: [["AcaciaFence", 3]], - // }, - // { - // inputs: [ - // ["SprucePlanks", 4], - // ["Stick", 2], - // ], - // outputs: [["SpruceFence", 3]], - // }, - // { - // inputs: [ - // ["DarkOakPlanks", 4], - // ["Stick", 2], - // ], - // outputs: [["DarkOakFence", 3]], - // }, - // { - // inputs: [ - // ["MangrovePlanks", 4], - // ["Stick", 2], - // ], - // outputs: [["MangroveFence", 3]], - // }, + + // Fences + { + inputs: [ + ["OakPlanks", 4], + ["Stick", 2], + ], + outputs: [["OakFence", 3]], + }, + { + inputs: [ + ["BirchPlanks", 4], + ["Stick", 2], + ], + outputs: [["BirchFence", 3]], + }, + { + inputs: [ + ["JunglePlanks", 4], + ["Stick", 2], + ], + outputs: [["JungleFence", 3]], + }, + { + inputs: [ + ["SakuraPlanks", 4], + ["Stick", 2], + ], + outputs: [["SakuraFence", 3]], + }, + { + inputs: [ + ["AcaciaPlanks", 4], + ["Stick", 2], + ], + outputs: [["AcaciaFence", 3]], + }, + { + inputs: [ + ["SprucePlanks", 4], + ["Stick", 2], + ], + outputs: [["SpruceFence", 3]], + }, + { + inputs: [ + ["DarkOakPlanks", 4], + ["Stick", 2], + ], + outputs: [["DarkOakFence", 3]], + }, + { + inputs: [ + ["MangrovePlanks", 4], + ["Stick", 2], + ], + outputs: [["MangroveFence", 3]], + }, + + // Fence gates // { // inputs: [ // ["Stick", 4], @@ -1552,6 +1557,7 @@ export const recipes: Recipe[] = [ // ], // outputs: [["MangroveFenceGate", 1]], // }, + // { // inputs: [["IronBar", 3]], // outputs: [["IronBars", 8]], @@ -1598,464 +1604,464 @@ export const recipes: Recipe[] = [ station: "Workbench", }, // Stairs recipes - // { - // station: "Stonecutter", - // inputs: [["Stone", 1]], - // outputs: [["StoneStairs", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["Cobblestone", 1]], - // outputs: [["CobblestoneStairs", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["MossyCobblestone", 1]], - // outputs: [["MossyCobblestoneStairs", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["StoneBricks", 1]], - // outputs: [["StoneBricksStairs", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["SmoothStone", 1]], - // outputs: [["SmoothStoneStairs", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["Andesite", 1]], - // outputs: [["AndesiteStairs", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["Granite", 1]], - // outputs: [["GraniteStairs", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["Diorite", 1]], - // outputs: [["DioriteStairs", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["Tuff", 1]], - // outputs: [["TuffStairs", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["Basalt", 1]], - // outputs: [["BasaltStairs", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["Blackstone", 1]], - // outputs: [["BlackstoneStairs", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["PolishedAndesite", 1]], - // outputs: [["PolishedAndesiteStairs", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["PolishedGranite", 1]], - // outputs: [["PolishedGraniteStairs", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["PolishedDiorite", 1]], - // outputs: [["PolishedDioriteStairs", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["PolishedTuff", 1]], - // outputs: [["PolishedTuffStairs", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["PolishedBasalt", 1]], - // outputs: [["PolishedBasaltStairs", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["PolishedBlackstone", 1]], - // outputs: [["PolishedBlackstoneStairs", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["Deepslate", 1]], - // outputs: [["DeepslateStairs", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["CobbledDeepslate", 1]], - // outputs: [["CobbledDeepslateStairs", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["DeepslateBricks", 1]], - // outputs: [["DeepslateBricksStairs", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["Sandstone", 1]], - // outputs: [["SandstoneStairs", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["RedSandstone", 1]], - // outputs: [["RedSandstoneStairs", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["SmoothSandstone", 1]], - // outputs: [["SmoothSandstoneStairs", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["SmoothRedSandstone", 1]], - // outputs: [["SmoothRedSandstoneStairs", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["BrickBlock", 1]], - // outputs: [["BrickBlockStairs", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["MudBricks", 1]], - // outputs: [["MudBricksStairs", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["TuffBricks", 1]], - // outputs: [["TuffBricksStairs", 1]], - // }, + { + station: "Stonecutter", + inputs: [["Stone", 1]], + outputs: [["StoneStairs", 1]], + }, + { + station: "Stonecutter", + inputs: [["Cobblestone", 1]], + outputs: [["CobblestoneStairs", 1]], + }, + { + station: "Stonecutter", + inputs: [["MossyCobblestone", 1]], + outputs: [["MossyCobblestoneStairs", 1]], + }, + { + station: "Stonecutter", + inputs: [["StoneBricks", 1]], + outputs: [["StoneBricksStairs", 1]], + }, + { + station: "Stonecutter", + inputs: [["SmoothStone", 1]], + outputs: [["SmoothStoneStairs", 1]], + }, + { + station: "Stonecutter", + inputs: [["Andesite", 1]], + outputs: [["AndesiteStairs", 1]], + }, + { + station: "Stonecutter", + inputs: [["Granite", 1]], + outputs: [["GraniteStairs", 1]], + }, + { + station: "Stonecutter", + inputs: [["Diorite", 1]], + outputs: [["DioriteStairs", 1]], + }, + { + station: "Stonecutter", + inputs: [["Tuff", 1]], + outputs: [["TuffStairs", 1]], + }, + { + station: "Stonecutter", + inputs: [["Basalt", 1]], + outputs: [["BasaltStairs", 1]], + }, + { + station: "Stonecutter", + inputs: [["Blackstone", 1]], + outputs: [["BlackstoneStairs", 1]], + }, + { + station: "Stonecutter", + inputs: [["PolishedAndesite", 1]], + outputs: [["PolishedAndesiteStairs", 1]], + }, + { + station: "Stonecutter", + inputs: [["PolishedGranite", 1]], + outputs: [["PolishedGraniteStairs", 1]], + }, + { + station: "Stonecutter", + inputs: [["PolishedDiorite", 1]], + outputs: [["PolishedDioriteStairs", 1]], + }, + { + station: "Stonecutter", + inputs: [["PolishedTuff", 1]], + outputs: [["PolishedTuffStairs", 1]], + }, + { + station: "Stonecutter", + inputs: [["PolishedBasalt", 1]], + outputs: [["PolishedBasaltStairs", 1]], + }, + { + station: "Stonecutter", + inputs: [["PolishedBlackstone", 1]], + outputs: [["PolishedBlackstoneStairs", 1]], + }, + { + station: "Stonecutter", + inputs: [["Deepslate", 1]], + outputs: [["DeepslateStairs", 1]], + }, + { + station: "Stonecutter", + inputs: [["CobbledDeepslate", 1]], + outputs: [["CobbledDeepslateStairs", 1]], + }, + { + station: "Stonecutter", + inputs: [["DeepslateBricks", 1]], + outputs: [["DeepslateBricksStairs", 1]], + }, + { + station: "Stonecutter", + inputs: [["Sandstone", 1]], + outputs: [["SandstoneStairs", 1]], + }, + { + station: "Stonecutter", + inputs: [["RedSandstone", 1]], + outputs: [["RedSandstoneStairs", 1]], + }, + { + station: "Stonecutter", + inputs: [["SmoothSandstone", 1]], + outputs: [["SmoothSandstoneStairs", 1]], + }, + { + station: "Stonecutter", + inputs: [["SmoothRedSandstone", 1]], + outputs: [["SmoothRedSandstoneStairs", 1]], + }, + { + station: "Stonecutter", + inputs: [["BrickBlock", 1]], + outputs: [["BrickBlockStairs", 1]], + }, + { + station: "Stonecutter", + inputs: [["MudBricks", 1]], + outputs: [["MudBricksStairs", 1]], + }, + { + station: "Stonecutter", + inputs: [["TuffBricks", 1]], + outputs: [["TuffBricksStairs", 1]], + }, // Wooden stairs - // { - // inputs: [["OakPlanks", 1]], - // outputs: [["OakPlanksStairs", 1]], - // }, - // { - // inputs: [["BirchPlanks", 1]], - // outputs: [["BirchPlanksStairs", 1]], - // }, - // { - // inputs: [["JunglePlanks", 1]], - // outputs: [["JunglePlanksStairs", 1]], - // }, - // { - // inputs: [["SakuraPlanks", 1]], - // outputs: [["SakuraPlanksStairs", 1]], - // }, - // { - // inputs: [["AcaciaPlanks", 1]], - // outputs: [["AcaciaPlanksStairs", 1]], - // }, - // { - // inputs: [["SprucePlanks", 1]], - // outputs: [["SprucePlanksStairs", 1]], - // }, - // { - // inputs: [["DarkOakPlanks", 1]], - // outputs: [["DarkOakPlanksStairs", 1]], - // }, - // { - // inputs: [["MangrovePlanks", 1]], - // outputs: [["MangrovePlanksStairs", 1]], - // }, + { + inputs: [["OakPlanks", 1]], + outputs: [["OakPlanksStairs", 1]], + }, + { + inputs: [["BirchPlanks", 1]], + outputs: [["BirchPlanksStairs", 1]], + }, + { + inputs: [["JunglePlanks", 1]], + outputs: [["JunglePlanksStairs", 1]], + }, + { + inputs: [["SakuraPlanks", 1]], + outputs: [["SakuraPlanksStairs", 1]], + }, + { + inputs: [["AcaciaPlanks", 1]], + outputs: [["AcaciaPlanksStairs", 1]], + }, + { + inputs: [["SprucePlanks", 1]], + outputs: [["SprucePlanksStairs", 1]], + }, + { + inputs: [["DarkOakPlanks", 1]], + outputs: [["DarkOakPlanksStairs", 1]], + }, + { + inputs: [["MangrovePlanks", 1]], + outputs: [["MangrovePlanksStairs", 1]], + }, // Slab recipes - // { - // station: "Stonecutter", - // inputs: [["Stone", 1]], - // outputs: [["StoneSlab", 2]], - // }, - // { - // station: "Stonecutter", - // inputs: [["Cobblestone", 1]], - // outputs: [["CobblestoneSlab", 2]], - // }, - // { - // station: "Stonecutter", - // inputs: [["MossyCobblestone", 1]], - // outputs: [["MossyCobblestoneSlab", 2]], - // }, - // { - // station: "Stonecutter", - // inputs: [["StoneBricks", 1]], - // outputs: [["StoneBricksSlab", 2]], - // }, - // { - // station: "Stonecutter", - // inputs: [["SmoothStone", 1]], - // outputs: [["SmoothStoneSlab", 2]], - // }, - // { - // station: "Stonecutter", - // inputs: [["Andesite", 1]], - // outputs: [["AndesiteSlab", 2]], - // }, - // { - // station: "Stonecutter", - // inputs: [["Granite", 1]], - // outputs: [["GraniteSlab", 2]], - // }, - // { - // station: "Stonecutter", - // inputs: [["Diorite", 1]], - // outputs: [["DioriteSlab", 2]], - // }, - // { - // station: "Stonecutter", - // inputs: [["Tuff", 1]], - // outputs: [["TuffSlab", 2]], - // }, - // { - // station: "Stonecutter", - // inputs: [["Basalt", 1]], - // outputs: [["BasaltSlab", 2]], - // }, - // { - // station: "Stonecutter", - // inputs: [["Blackstone", 1]], - // outputs: [["BlackstoneSlab", 2]], - // }, - // { - // station: "Stonecutter", - // inputs: [["PolishedAndesite", 1]], - // outputs: [["PolishedAndesiteSlab", 2]], - // }, - // { - // station: "Stonecutter", - // inputs: [["PolishedGranite", 1]], - // outputs: [["PolishedGraniteSlab", 2]], - // }, - // { - // station: "Stonecutter", - // inputs: [["PolishedDiorite", 1]], - // outputs: [["PolishedDioriteSlab", 2]], - // }, - // { - // station: "Stonecutter", - // inputs: [["PolishedTuff", 1]], - // outputs: [["PolishedTuffSlab", 2]], - // }, - // { - // station: "Stonecutter", - // inputs: [["PolishedBasalt", 1]], - // outputs: [["PolishedBasaltSlab", 2]], - // }, - // { - // station: "Stonecutter", - // inputs: [["PolishedBlackstone", 1]], - // outputs: [["PolishedBlackstoneSlab", 2]], - // }, - // { - // station: "Stonecutter", - // inputs: [["Deepslate", 1]], - // outputs: [["DeepslateSlab", 2]], - // }, - // { - // station: "Stonecutter", - // inputs: [["CobbledDeepslate", 1]], - // outputs: [["CobbledDeepslateSlab", 2]], - // }, - // { - // station: "Stonecutter", - // inputs: [["DeepslateBricks", 1]], - // outputs: [["DeepslateBricksSlab", 2]], - // }, - // { - // station: "Stonecutter", - // inputs: [["Sandstone", 1]], - // outputs: [["SandstoneSlab", 2]], - // }, - // { - // station: "Stonecutter", - // inputs: [["RedSandstone", 1]], - // outputs: [["RedSandstoneSlab", 2]], - // }, - // { - // station: "Stonecutter", - // inputs: [["SmoothSandstone", 1]], - // outputs: [["SmoothSandstoneSlab", 2]], - // }, - // { - // station: "Stonecutter", - // inputs: [["SmoothRedSandstone", 1]], - // outputs: [["SmoothRedSandstoneSlab", 2]], - // }, - // { - // station: "Stonecutter", - // inputs: [["BrickBlock", 1]], - // outputs: [["BrickBlockSlab", 2]], - // }, - // { - // station: "Stonecutter", - // inputs: [["MudBricks", 1]], - // outputs: [["MudBricksSlab", 2]], - // }, - // { - // station: "Stonecutter", - // inputs: [["TuffBricks", 1]], - // outputs: [["TuffBricksSlab", 2]], - // }, + { + station: "Stonecutter", + inputs: [["Stone", 1]], + outputs: [["StoneSlab", 2]], + }, + { + station: "Stonecutter", + inputs: [["Cobblestone", 1]], + outputs: [["CobblestoneSlab", 2]], + }, + { + station: "Stonecutter", + inputs: [["MossyCobblestone", 1]], + outputs: [["MossyCobblestoneSlab", 2]], + }, + { + station: "Stonecutter", + inputs: [["StoneBricks", 1]], + outputs: [["StoneBricksSlab", 2]], + }, + { + station: "Stonecutter", + inputs: [["SmoothStone", 1]], + outputs: [["SmoothStoneSlab", 2]], + }, + { + station: "Stonecutter", + inputs: [["Andesite", 1]], + outputs: [["AndesiteSlab", 2]], + }, + { + station: "Stonecutter", + inputs: [["Granite", 1]], + outputs: [["GraniteSlab", 2]], + }, + { + station: "Stonecutter", + inputs: [["Diorite", 1]], + outputs: [["DioriteSlab", 2]], + }, + { + station: "Stonecutter", + inputs: [["Tuff", 1]], + outputs: [["TuffSlab", 2]], + }, + { + station: "Stonecutter", + inputs: [["Basalt", 1]], + outputs: [["BasaltSlab", 2]], + }, + { + station: "Stonecutter", + inputs: [["Blackstone", 1]], + outputs: [["BlackstoneSlab", 2]], + }, + { + station: "Stonecutter", + inputs: [["PolishedAndesite", 1]], + outputs: [["PolishedAndesiteSlab", 2]], + }, + { + station: "Stonecutter", + inputs: [["PolishedGranite", 1]], + outputs: [["PolishedGraniteSlab", 2]], + }, + { + station: "Stonecutter", + inputs: [["PolishedDiorite", 1]], + outputs: [["PolishedDioriteSlab", 2]], + }, + { + station: "Stonecutter", + inputs: [["PolishedTuff", 1]], + outputs: [["PolishedTuffSlab", 2]], + }, + { + station: "Stonecutter", + inputs: [["PolishedBasalt", 1]], + outputs: [["PolishedBasaltSlab", 2]], + }, + { + station: "Stonecutter", + inputs: [["PolishedBlackstone", 1]], + outputs: [["PolishedBlackstoneSlab", 2]], + }, + { + station: "Stonecutter", + inputs: [["Deepslate", 1]], + outputs: [["DeepslateSlab", 2]], + }, + { + station: "Stonecutter", + inputs: [["CobbledDeepslate", 1]], + outputs: [["CobbledDeepslateSlab", 2]], + }, + { + station: "Stonecutter", + inputs: [["DeepslateBricks", 1]], + outputs: [["DeepslateBricksSlab", 2]], + }, + { + station: "Stonecutter", + inputs: [["Sandstone", 1]], + outputs: [["SandstoneSlab", 2]], + }, + { + station: "Stonecutter", + inputs: [["RedSandstone", 1]], + outputs: [["RedSandstoneSlab", 2]], + }, + { + station: "Stonecutter", + inputs: [["SmoothSandstone", 1]], + outputs: [["SmoothSandstoneSlab", 2]], + }, + { + station: "Stonecutter", + inputs: [["SmoothRedSandstone", 1]], + outputs: [["SmoothRedSandstoneSlab", 2]], + }, + { + station: "Stonecutter", + inputs: [["BrickBlock", 1]], + outputs: [["BrickBlockSlab", 2]], + }, + { + station: "Stonecutter", + inputs: [["MudBricks", 1]], + outputs: [["MudBricksSlab", 2]], + }, + { + station: "Stonecutter", + inputs: [["TuffBricks", 1]], + outputs: [["TuffBricksSlab", 2]], + }, // Wooden slabs - // { - // inputs: [["OakPlanks", 1]], - // outputs: [["OakPlanksSlab", 2]], - // }, - // { - // inputs: [["BirchPlanks", 1]], - // outputs: [["BirchPlanksSlab", 2]], - // }, - // { - // inputs: [["JunglePlanks", 1]], - // outputs: [["JunglePlanksSlab", 2]], - // }, - // { - // inputs: [["SakuraPlanks", 1]], - // outputs: [["SakuraPlanksSlab", 2]], - // }, - // { - // inputs: [["AcaciaPlanks", 1]], - // outputs: [["AcaciaPlanksSlab", 2]], - // }, - // { - // inputs: [["SprucePlanks", 1]], - // outputs: [["SprucePlanksSlab", 2]], - // }, - // { - // inputs: [["DarkOakPlanks", 1]], - // outputs: [["DarkOakPlanksSlab", 2]], - // }, - // { - // inputs: [["MangrovePlanks", 1]], - // outputs: [["MangrovePlanksSlab", 2]], - // }, + { + inputs: [["OakPlanks", 1]], + outputs: [["OakPlanksSlab", 2]], + }, + { + inputs: [["BirchPlanks", 1]], + outputs: [["BirchPlanksSlab", 2]], + }, + { + inputs: [["JunglePlanks", 1]], + outputs: [["JunglePlanksSlab", 2]], + }, + { + inputs: [["SakuraPlanks", 1]], + outputs: [["SakuraPlanksSlab", 2]], + }, + { + inputs: [["AcaciaPlanks", 1]], + outputs: [["AcaciaPlanksSlab", 2]], + }, + { + inputs: [["SprucePlanks", 1]], + outputs: [["SprucePlanksSlab", 2]], + }, + { + inputs: [["DarkOakPlanks", 1]], + outputs: [["DarkOakPlanksSlab", 2]], + }, + { + inputs: [["MangrovePlanks", 1]], + outputs: [["MangrovePlanksSlab", 2]], + }, // Wall recipes - // { - // station: "Stonecutter", - // inputs: [["Stone", 1]], - // outputs: [["StoneWall", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["Cobblestone", 1]], - // outputs: [["CobblestoneWall", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["MossyCobblestone", 1]], - // outputs: [["MossyCobblestoneWall", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["StoneBricks", 1]], - // outputs: [["StoneBricksWall", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["Andesite", 1]], - // outputs: [["AndesiteWall", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["Granite", 1]], - // outputs: [["GraniteWall", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["Diorite", 1]], - // outputs: [["DioriteWall", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["Tuff", 1]], - // outputs: [["TuffWall", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["Basalt", 1]], - // outputs: [["BasaltWall", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["Blackstone", 1]], - // outputs: [["BlackstoneWall", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["PolishedAndesite", 1]], - // outputs: [["PolishedAndesiteWall", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["PolishedGranite", 1]], - // outputs: [["PolishedGraniteWall", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["PolishedDiorite", 1]], - // outputs: [["PolishedDioriteWall", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["PolishedTuff", 1]], - // outputs: [["PolishedTuffWall", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["PolishedBasalt", 1]], - // outputs: [["PolishedBasaltWall", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["PolishedBlackstone", 1]], - // outputs: [["PolishedBlackstoneWall", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["Deepslate", 1]], - // outputs: [["DeepslateWall", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["CobbledDeepslate", 1]], - // outputs: [["CobbledDeepslateWall", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["DeepslateBricks", 1]], - // outputs: [["DeepslateBricksWall", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["Sandstone", 1]], - // outputs: [["SandstoneWall", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["RedSandstone", 1]], - // outputs: [["RedSandstoneWall", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["BrickBlock", 1]], - // outputs: [["BrickBlockWall", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["MudBricks", 1]], - // outputs: [["MudBricksWall", 1]], - // }, - // { - // station: "Stonecutter", - // inputs: [["TuffBricks", 1]], - // outputs: [["TuffBricksWall", 1]], - // }, + { + station: "Stonecutter", + inputs: [["Stone", 1]], + outputs: [["StoneWall", 1]], + }, + { + station: "Stonecutter", + inputs: [["Cobblestone", 1]], + outputs: [["CobblestoneWall", 1]], + }, + { + station: "Stonecutter", + inputs: [["MossyCobblestone", 1]], + outputs: [["MossyCobblestoneWall", 1]], + }, + { + station: "Stonecutter", + inputs: [["StoneBricks", 1]], + outputs: [["StoneBricksWall", 1]], + }, + { + station: "Stonecutter", + inputs: [["Andesite", 1]], + outputs: [["AndesiteWall", 1]], + }, + { + station: "Stonecutter", + inputs: [["Granite", 1]], + outputs: [["GraniteWall", 1]], + }, + { + station: "Stonecutter", + inputs: [["Diorite", 1]], + outputs: [["DioriteWall", 1]], + }, + { + station: "Stonecutter", + inputs: [["Tuff", 1]], + outputs: [["TuffWall", 1]], + }, + { + station: "Stonecutter", + inputs: [["Basalt", 1]], + outputs: [["BasaltWall", 1]], + }, + { + station: "Stonecutter", + inputs: [["Blackstone", 1]], + outputs: [["BlackstoneWall", 1]], + }, + { + station: "Stonecutter", + inputs: [["PolishedAndesite", 1]], + outputs: [["PolishedAndesiteWall", 1]], + }, + { + station: "Stonecutter", + inputs: [["PolishedGranite", 1]], + outputs: [["PolishedGraniteWall", 1]], + }, + { + station: "Stonecutter", + inputs: [["PolishedDiorite", 1]], + outputs: [["PolishedDioriteWall", 1]], + }, + { + station: "Stonecutter", + inputs: [["PolishedTuff", 1]], + outputs: [["PolishedTuffWall", 1]], + }, + { + station: "Stonecutter", + inputs: [["PolishedBasalt", 1]], + outputs: [["PolishedBasaltWall", 1]], + }, + { + station: "Stonecutter", + inputs: [["PolishedBlackstone", 1]], + outputs: [["PolishedBlackstoneWall", 1]], + }, + { + station: "Stonecutter", + inputs: [["Deepslate", 1]], + outputs: [["DeepslateWall", 1]], + }, + { + station: "Stonecutter", + inputs: [["CobbledDeepslate", 1]], + outputs: [["CobbledDeepslateWall", 1]], + }, + { + station: "Stonecutter", + inputs: [["DeepslateBricks", 1]], + outputs: [["DeepslateBricksWall", 1]], + }, + { + station: "Stonecutter", + inputs: [["Sandstone", 1]], + outputs: [["SandstoneWall", 1]], + }, + { + station: "Stonecutter", + inputs: [["RedSandstone", 1]], + outputs: [["RedSandstoneWall", 1]], + }, + { + station: "Stonecutter", + inputs: [["BrickBlock", 1]], + outputs: [["BrickBlockWall", 1]], + }, + { + station: "Stonecutter", + inputs: [["MudBricks", 1]], + outputs: [["MudBricksWall", 1]], + }, + { + station: "Stonecutter", + inputs: [["TuffBricks", 1]], + outputs: [["TuffBricksWall", 1]], + }, ]; // Get recipes where an object is used as input diff --git a/packages/world/ts/scripts/analyze-recipes.ts b/packages/world/ts/scripts/analyze-recipes.ts new file mode 100644 index 00000000..115d276a --- /dev/null +++ b/packages/world/ts/scripts/analyze-recipes.ts @@ -0,0 +1,295 @@ +import { type ObjectName, objects, objectsByName } from "../objects"; +import { type Recipe, recipes } from "../recipes"; + +// Helper function to get total mass+energy of object amounts +function getTotalMassEnergy( + items: [ObjectName, number | bigint][], +): bigint | undefined { + let totalMassEnergy = 0n; + let hasValue = false; + + for (const [objName, amount] of items) { + const obj = objectsByName[objName]; + if (!obj) { + console.warn(`Warning: Unknown object "${objName}"`); + continue; + } + + if (obj.mass !== undefined) { + hasValue = true; + totalMassEnergy += obj.mass * BigInt(amount); + } + + if (obj.energy !== undefined) { + hasValue = true; + totalMassEnergy += obj.energy * BigInt(amount); + } + } + + return hasValue ? totalMassEnergy : undefined; +} + +// Get all objects that are used as outputs in recipes +const objectsWithRecipes = new Set(); +for (const recipe of recipes) { + for (const [outputName] of recipe.outputs) { + objectsWithRecipes.add(outputName); + } +} + +// Sort objects by ID for consistent output +const sortedObjects = [...objects].sort((a, b) => a.id - b.id); + +console.info("Recipe Analysis"); +console.info("==============="); +console.info(`Total recipes: ${recipes.length}`); +console.info(`Total objects: ${objects.length}`); +console.info(""); + +// Mass+Energy conservation analysis +console.info("Mass+Energy Conservation Analysis:"); +console.info("----------------------------------"); +console.info( + "(Recipes where both inputs and outputs have mass and/or energy defined)\n", +); + +let conservedCount = 0; +let nonConservedCount = 0; +const massEnergyViolations: { + recipe: Recipe; + inputTotal: bigint; + outputTotal: bigint; + ratio: number; +}[] = []; + +for (const recipe of recipes) { + const inputTotal = getTotalMassEnergy(recipe.inputs); + const outputTotal = getTotalMassEnergy(recipe.outputs); + + if (inputTotal !== undefined && outputTotal !== undefined) { + const ratio = Number(outputTotal) / Number(inputTotal); + + if (inputTotal === outputTotal) { + conservedCount++; + } else { + nonConservedCount++; + massEnergyViolations.push({ recipe, inputTotal, outputTotal, ratio }); + } + } +} + +console.info(`Recipes with mass+energy conservation: ${conservedCount}`); +console.info( + `Recipes violating mass+energy conservation: ${nonConservedCount}`, +); + +if (massEnergyViolations.length > 0) { + console.info("\nMass+Energy violations (sorted by ratio):"); + const sorted = massEnergyViolations.sort((a, b) => a.ratio - b.ratio); + + for (const { recipe, inputTotal, outputTotal, ratio } of sorted) { + const inputs = recipe.inputs + .map(([name, amt]) => `${amt}x ${name}`) + .join(" + "); + const outputs = recipe.outputs + .map(([name, amt]) => `${amt}x ${name}`) + .join(" + "); + const station = recipe.station ? ` @ ${recipe.station}` : ""; + console.info(` ${inputs} → ${outputs}${station}`); + console.info( + ` Input total: ${inputTotal}, Output total: ${outputTotal}, Ratio: ${ratio.toFixed(3)}`, + ); + } +} + +// Non-terrain objects (id > 255) without recipes +console.info("\n\nNon-terrain objects (ID > 255) without recipes:"); +console.info("------------------------------------------------"); + +const nonTerrainWithoutRecipes: (typeof objects)[0][] = []; +for (const obj of sortedObjects) { + if (obj.id > 255 && !objectsWithRecipes.has(obj.name)) { + nonTerrainWithoutRecipes.push(obj); + } +} + +if (nonTerrainWithoutRecipes.length > 0) { + for (const obj of nonTerrainWithoutRecipes) { + console.info(`- ${obj.name} (ID: ${obj.id})`); + } + console.info(`Total: ${nonTerrainWithoutRecipes.length} objects`); +} else { + console.info("None found - all non-terrain objects have recipes!"); +} + +// Find objects that are only inputs (never crafted) +console.info("\n\nObjects that are never crafted (only used as inputs):"); +console.info("-----------------------------------------------------"); + +const inputOnlyObjects = new Set(); +for (const recipe of recipes) { + for (const [inputName] of recipe.inputs) { + if (!objectsWithRecipes.has(inputName)) { + inputOnlyObjects.add(inputName); + } + } +} + +const sortedInputOnly = Array.from(inputOnlyObjects).sort(); +for (const objName of sortedInputOnly) { + const obj = objectsByName[objName]; + if (obj) { + console.info(`- ${objName} (ID: ${obj.id})`); + } +} + +// Recipe cycles (objects that can be converted back to themselves) +console.info("\n\nRecipe Cycles Detection:"); +console.info("------------------------"); + +// Build a graph of what can be crafted into what +const craftingGraph = new Map>(); + +for (const recipe of recipes) { + for (const [inputName] of recipe.inputs) { + if (!craftingGraph.has(inputName)) { + craftingGraph.set(inputName, new Set()); + } + for (const [outputName] of recipe.outputs) { + craftingGraph.get(inputName)!.add(outputName); + } + } +} + +// Simple cycle detection (depth-limited to avoid infinite loops) +function findCycles( + start: ObjectName, + current: ObjectName, + visited: Set, + depth: number, +): boolean { + if (depth > 10) return false; // Limit depth to avoid deep recursion + if (current === start && depth > 0) return true; + if (visited.has(current)) return false; + + visited.add(current); + const outputs = craftingGraph.get(current); + if (outputs) { + for (const output of outputs) { + if (findCycles(start, output, new Set(visited), depth + 1)) { + return true; + } + } + } + return false; +} + +const objectsWithCycles = new Set(); +for (const obj of objects) { + if (findCycles(obj.name, obj.name, new Set(), 0)) { + objectsWithCycles.add(obj.name); + } +} + +if (objectsWithCycles.size > 0) { + console.info( + "Objects that can be cycled back to themselves through recipes:", + ); + for (const objName of Array.from(objectsWithCycles).sort()) { + console.info(`- ${objName}`); + } +} else { + console.info("No recipe cycles detected!"); +} + +// Recipe efficiency analysis (output/input ratio) +console.info("\n\nRecipe Efficiency (by item count):"); +console.info("----------------------------------"); + +const efficiencyData: { recipe: Recipe; efficiency: number }[] = []; + +for (const recipe of recipes) { + const inputCount = recipe.inputs.reduce( + (sum, [_, amt]) => sum + Number(amt), + 0, + ); + const outputCount = recipe.outputs.reduce( + (sum, [_, amt]) => sum + Number(amt), + 0, + ); + const efficiency = outputCount / inputCount; + efficiencyData.push({ recipe, efficiency }); +} + +// Show top 10 most efficient recipes +console.info("\nTop 10 most efficient recipes:"); +const topEfficient = efficiencyData + .sort((a, b) => b.efficiency - a.efficiency) + .slice(0, 10); +for (const { recipe, efficiency } of topEfficient) { + const inputs = recipe.inputs + .map(([name, amt]) => `${amt}x ${name}`) + .join(" + "); + const outputs = recipe.outputs + .map(([name, amt]) => `${amt}x ${name}`) + .join(" + "); + const station = recipe.station ? ` @ ${recipe.station}` : ""; + console.info( + `- ${inputs} → ${outputs}${station} (${efficiency.toFixed(2)}x)`, + ); +} + +// Stations usage statistics +console.info("\n\nCrafting Station Usage:"); +console.info("-----------------------"); + +const stationUsage = new Map(); +stationUsage.set("Hand", 0); + +for (const recipe of recipes) { + const station = recipe.station || "Hand"; + stationUsage.set(station, (stationUsage.get(station) || 0) + 1); +} + +for (const [station, count] of Array.from(stationUsage.entries()).sort( + (a, b) => b[1] - a[1], +)) { + const percentage = ((count / recipes.length) * 100).toFixed(1); + console.info(`${station}: ${count} recipes (${percentage}%)`); +} + +// Special category recipes +console.info("\n\nSpecial Recipe Categories:"); +console.info("--------------------------"); + +// Recipes with multiple inputs +const multiInputRecipes = recipes.filter((r) => r.inputs.length > 1); +console.info(`\nRecipes with multiple inputs: ${multiInputRecipes.length}`); +if (multiInputRecipes.length > 0 && multiInputRecipes.length <= 20) { + for (const recipe of multiInputRecipes) { + const inputs = recipe.inputs + .map(([name, amt]) => `${amt}x ${name}`) + .join(" + "); + const outputs = recipe.outputs + .map(([name, amt]) => `${amt}x ${name}`) + .join(" + "); + const station = recipe.station ? ` @ ${recipe.station}` : ""; + console.info(` ${inputs} → ${outputs}${station}`); + } +} + +// Recipes with multiple outputs +const multiOutputRecipes = recipes.filter((r) => r.outputs.length > 1); +console.info(`\nRecipes with multiple outputs: ${multiOutputRecipes.length}`); +if (multiOutputRecipes.length > 0 && multiOutputRecipes.length <= 20) { + for (const recipe of multiOutputRecipes) { + const inputs = recipe.inputs + .map(([name, amt]) => `${amt}x ${name}`) + .join(" + "); + const outputs = recipe.outputs + .map(([name, amt]) => `${amt}x ${name}`) + .join(" + "); + const station = recipe.station ? ` @ ${recipe.station}` : ""; + console.info(` ${inputs} → ${outputs}${station}`); + } +} diff --git a/packages/world/ts/scripts/genObjectTypeSol.ts b/packages/world/ts/scripts/genObjectTypeSol.ts index aaf51671..6a03c1ea 100644 --- a/packages/world/ts/scripts/genObjectTypeSol.ts +++ b/packages/world/ts/scripts/genObjectTypeSol.ts @@ -92,8 +92,8 @@ pragma solidity >=0.8.24; import { IMachineSystem } from "../codegen/world/IMachineSystem.sol"; import { ITransferSystem } from "../codegen/world/ITransferSystem.sol"; -import { Vec3, vec3 } from "./Vec3.sol"; import { Orientation } from "./Orientation.sol"; +import { Vec3, vec3 } from "./Vec3.sol"; type ObjectType is uint16; @@ -192,16 +192,18 @@ ${Object.entries(categories) } function isOrientationSupported(ObjectType self, Orientation orientation) internal pure returns (bool) { - ${objects - .filter((obj) => obj.supportedOrientations !== undefined) - .map((obj) => { - return `if (self == ObjectTypes.${obj.name}) { - return ${obj.supportedOrientations!.map((orientation) => `orientation == Orientation.wrap(${orientation})`).join(" || ")}; - }`; - }) - .join("\n ")} + uint8 orientationValue = Orientation.unwrap(orientation); + + // Check if orientation is valid (0-47) + if (orientationValue >= 48) return false; + + uint64 orientationBit = uint64(1) << orientationValue; + uint16 selfId = self.unwrap(); + + ${generateOrientationChecks()} - return orientation == Orientation.wrap(0); + // Default: only orientation 0 is supported + return orientationValue == 0; } function getRelativeCoords(ObjectType self, Vec3 baseCoord) internal pure returns (Vec3[] memory) { @@ -334,4 +336,88 @@ using ObjectTypeLib for ObjectType global; `; } +// Helper function to format orientation list +function getOrientationDescription(orientations: number[]): string { + return `[${orientations.sort((a, b) => a - b).join(", ")}]`; +} + +// Helper function to generate orientation checks +function generateOrientationChecks(): string { + // Group objects by their orientation mask + const orientationGroups = new Map< + string, + { objects: (typeof objects)[0][]; orientations: number[] } + >(); + + // Process all objects with supported orientations + for (const obj of objects) { + if (obj.supportedOrientations && obj.supportedOrientations.length > 0) { + // Create a bitmask for this object's supported orientations + let mask = 0n; + for (const orientation of obj.supportedOrientations) { + mask |= 1n << BigInt(orientation); + } + + const maskKey = mask.toString(16); + if (!orientationGroups.has(maskKey)) { + orientationGroups.set(maskKey, { + objects: [], + orientations: [...obj.supportedOrientations], + }); + } + orientationGroups.get(maskKey)!.objects.push(obj); + } + } + + // Generate checks for each orientation group + const checks: string[] = []; + + for (const [maskHex, group] of orientationGroups) { + const { objects: groupObjects, orientations } = group; + + // Group objects by ID ranges for more efficient checks + const idRanges: { start: number; end: number }[] = []; + const sortedObjects = [...groupObjects].sort((a, b) => a.id - b.id); + + let currentRange: { start: number; end: number } | null = null; + for (const obj of sortedObjects) { + if (!currentRange || obj.id > currentRange.end + 1) { + currentRange = { start: obj.id, end: obj.id }; + idRanges.push(currentRange); + } else { + currentRange.end = obj.id; + } + } + + // Generate conditions for this mask + const conditions: string[] = []; + + for (const range of idRanges) { + if (range.start === range.end) { + conditions.push(`selfId == ${range.start}`); + } else { + conditions.push(`(selfId >= ${range.start} && selfId <= ${range.end})`); + } + } + + if (conditions.length > 0) { + const objectNames = + groupObjects + .slice(0, 3) + .map((o) => o.name) + .join(", ") + (groupObjects.length > 3 ? "..." : ""); + + const orientationDesc = getOrientationDescription(orientations); + + const comment = `// Orientations ${orientationDesc}: ${objectNames}`; + checks.push(`${comment} + if (${conditions.join(" || ")}) { + return (orientationBit & 0x${maskHex}) != 0; + }`); + } + } + + return checks.join("\n "); +} + console.info(generateObjectTypeSol());