mirrors/Terra
1
0
Fork 0
mirror of https://github.com/PolyhedralDev/Terra.git synced 2026-04-20 15:20:25 +00:00
Code Issues Packages Projects Releases Wiki Activity

property based block data implementation

Browse Source
This commit is contained in:
dfsek
2021-06-26 02:17:31 -07:00
parent 43307b737c
commit bce7a181bd
45 changed files with 288 additions and 1542 deletions
Download Patch File Download Diff File Expand all files Collapse all files

175
platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/BukkitAdapter.java
View File

@@ -1,15 +1,12 @@
package com.dfsek.terra.bukkit.world;
import com.dfsek.terra.api.block.state.properties.enums.Half;
import com.dfsek.terra.api.block.state.properties.enums.RailShape;
import com.dfsek.terra.api.block.state.properties.enums.Axis;
import com.dfsek.terra.api.block.state.BlockState;
import com.dfsek.terra.api.block.BlockFace;
import com.dfsek.terra.api.block.BlockType;
import com.dfsek.terra.api.block.data.Bisected;
import com.dfsek.terra.api.block.data.RedstoneWire;
import com.dfsek.terra.api.block.data.Slab;
import com.dfsek.terra.api.block.data.Stairs;
import com.dfsek.terra.api.block.state.properties.enums.RedstoneConnection;
import com.dfsek.terra.api.entity.CommandSender;
import com.dfsek.terra.api.inventory.ItemStack;
import com.dfsek.terra.api.inventory.item.Enchantment;
@@ -50,23 +47,6 @@ public final class BukkitAdapter {
.build();
public static Stairs.Shape adapt(org.bukkit.block.data.type.Stairs.Shape shape) {
switch(shape) {
case STRAIGHT:
return Stairs.Shape.STRAIGHT;
case INNER_LEFT:
return Stairs.Shape.INNER_LEFT;
case OUTER_LEFT:
return Stairs.Shape.OUTER_LEFT;
case INNER_RIGHT:
return Stairs.Shape.INNER_RIGHT;
case OUTER_RIGHT:
return Stairs.Shape.OUTER_RIGHT;
default:
throw new IllegalStateException();
}
}
public static BlockState adapt(org.bukkit.block.data.BlockData data) {
return BukkitBlockState.newInstance(data);
}
@@ -88,89 +68,31 @@ public final class BukkitAdapter {
}
}
public static Bisected.Half adapt(org.bukkit.block.data.Bisected.Half half) {
public static Half adapt(org.bukkit.block.data.Bisected.Half half) {
switch(half) {
case BOTTOM:
return Bisected.Half.BOTTOM;
return Half.BOTTOM;
case TOP:
return Bisected.Half.TOP;
return Half.TOP;
default:
throw new IllegalStateException();
}
}
public static BlockFace adapt(org.bukkit.block.BlockFace face) {
switch(face) {
case DOWN:
return BlockFace.DOWN;
case UP:
return BlockFace.UP;
case NORTH_WEST:
return BlockFace.NORTH_WEST;
case NORTH_EAST:
return BlockFace.NORTH_EAST;
case SOUTH_EAST:
return BlockFace.SOUTH_EAST;
case SOUTH_WEST:
return BlockFace.SOUTH_WEST;
case NORTH_NORTH_WEST:
return BlockFace.NORTH_NORTH_WEST;
case WEST_NORTH_WEST:
return BlockFace.WEST_NORTH_WEST;
case WEST_SOUTH_WEST:
return BlockFace.WEST_SOUTH_WEST;
case SOUTH_SOUTH_WEST:
return BlockFace.SOUTH_SOUTH_WEST;
case EAST_NORTH_EAST:
return BlockFace.EAST_NORTH_EAST;
case WEST:
return BlockFace.WEST;
case SOUTH:
return BlockFace.SOUTH;
case EAST:
return BlockFace.EAST;
case NORTH:
return BlockFace.NORTH;
case SELF:
return BlockFace.SELF;
case EAST_SOUTH_EAST:
return BlockFace.EAST_SOUTH_EAST;
case NORTH_NORTH_EAST:
return BlockFace.NORTH_NORTH_EAST;
case SOUTH_SOUTH_EAST:
return BlockFace.SOUTH_SOUTH_EAST;
default:
throw new IllegalStateException();
}
}
public static Slab.Type adapt(org.bukkit.block.data.type.Slab.Type type) {
switch(type) {
case BOTTOM:
return Slab.Type.BOTTOM;
case TOP:
return Slab.Type.TOP;
case DOUBLE:
return Slab.Type.DOUBLE;
default:
throw new IllegalStateException();
}
}
public static RedstoneWire.Connection adapt(org.bukkit.block.data.type.RedstoneWire.Connection connection) {
public static RedstoneConnection adapt(org.bukkit.block.data.type.RedstoneWire.Connection connection) {
switch(connection) {
case NONE:
return RedstoneWire.Connection.NONE;
return RedstoneConnection.NONE;
case UP:
return RedstoneWire.Connection.UP;
return RedstoneConnection.UP;
case SIDE:
return RedstoneWire.Connection.SIDE;
return RedstoneConnection.SIDE;
default:
throw new IllegalStateException();
}
}
public static org.bukkit.block.data.type.RedstoneWire.Connection adapt(RedstoneWire.Connection connection) {
public static org.bukkit.block.data.type.RedstoneWire.Connection adapt(RedstoneConnection connection) {
switch(connection) {
case SIDE:
return org.bukkit.block.data.type.RedstoneWire.Connection.SIDE;
@@ -183,23 +105,6 @@ public final class BukkitAdapter {
}
}
public static org.bukkit.block.data.type.Stairs.Shape adapt(Stairs.Shape shape) {
switch(shape) {
case STRAIGHT:
return org.bukkit.block.data.type.Stairs.Shape.STRAIGHT;
case INNER_LEFT:
return org.bukkit.block.data.type.Stairs.Shape.INNER_LEFT;
case OUTER_LEFT:
return org.bukkit.block.data.type.Stairs.Shape.OUTER_LEFT;
case INNER_RIGHT:
return org.bukkit.block.data.type.Stairs.Shape.INNER_RIGHT;
case OUTER_RIGHT:
return org.bukkit.block.data.type.Stairs.Shape.OUTER_RIGHT;
default:
throw new IllegalStateException();
}
}
public static RailShape adapt(org.bukkit.block.data.Rail.Shape shape) {
switch(shape) {
case SOUTH_WEST:
@@ -255,7 +160,7 @@ public final class BukkitAdapter {
}
public static org.bukkit.block.data.Bisected.Half adapt(Bisected.Half half) {
public static org.bukkit.block.data.Bisected.Half adapt(Half half) {
switch(half) {
case TOP:
return org.bukkit.block.data.Bisected.Half.TOP;
@@ -279,64 +184,6 @@ public final class BukkitAdapter {
}
}
public static org.bukkit.block.BlockFace adapt(BlockFace face) {
switch(face) {
case DOWN:
return org.bukkit.block.BlockFace.DOWN;
case UP:
return org.bukkit.block.BlockFace.UP;
case NORTH_WEST:
return org.bukkit.block.BlockFace.NORTH_WEST;
case NORTH_EAST:
return org.bukkit.block.BlockFace.NORTH_EAST;
case SOUTH_EAST:
return org.bukkit.block.BlockFace.SOUTH_EAST;
case SOUTH_WEST:
return org.bukkit.block.BlockFace.SOUTH_WEST;
case NORTH_NORTH_WEST:
return org.bukkit.block.BlockFace.NORTH_NORTH_WEST;
case WEST_NORTH_WEST:
return org.bukkit.block.BlockFace.WEST_NORTH_WEST;
case WEST_SOUTH_WEST:
return org.bukkit.block.BlockFace.WEST_SOUTH_WEST;
case SOUTH_SOUTH_WEST:
return org.bukkit.block.BlockFace.SOUTH_SOUTH_WEST;
case EAST_NORTH_EAST:
return org.bukkit.block.BlockFace.EAST_NORTH_EAST;
case WEST:
return org.bukkit.block.BlockFace.WEST;
case SOUTH:
return org.bukkit.block.BlockFace.SOUTH;
case EAST:
return org.bukkit.block.BlockFace.EAST;
case NORTH:
return org.bukkit.block.BlockFace.NORTH;
case SELF:
return org.bukkit.block.BlockFace.SELF;
case EAST_SOUTH_EAST:
return org.bukkit.block.BlockFace.EAST_SOUTH_EAST;
case NORTH_NORTH_EAST:
return org.bukkit.block.BlockFace.NORTH_NORTH_EAST;
case SOUTH_SOUTH_EAST:
return org.bukkit.block.BlockFace.SOUTH_SOUTH_EAST;
default:
throw new IllegalStateException();
}
}
public static org.bukkit.block.data.type.Slab.Type adapt(Slab.Type type) {
switch(type) {
case TOP:
return org.bukkit.block.data.type.Slab.Type.TOP;
case DOUBLE:
return org.bukkit.block.data.type.Slab.Type.DOUBLE;
case BOTTOM:
return org.bukkit.block.data.type.Slab.Type.BOTTOM;
default:
throw new IllegalStateException();
}
}
public static Vector3 adapt(Location location) {
return new Vector3Impl(location.getX(), location.getY(), location.getZ());
}

24
platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/data/BukkitAnaloguePowerable.java
View File

@@ -1,24 +0,0 @@
package com.dfsek.terra.bukkit.world.block.data;
import com.dfsek.terra.api.block.data.AnaloguePowerable;
public class BukkitAnaloguePowerable extends BukkitBlockState implements AnaloguePowerable {
public BukkitAnaloguePowerable(org.bukkit.block.data.AnaloguePowerable delegate) {
super(delegate);
}
@Override
public int getMaximumPower() {
return ((org.bukkit.block.data.AnaloguePowerable) getHandle()).getMaximumPower();
}
@Override
public int getPower() {
return ((org.bukkit.block.data.AnaloguePowerable) getHandle()).getPower();
}
@Override
public void setPower(int power) {
((org.bukkit.block.data.AnaloguePowerable) getHandle()).setPower(power);
}
}

18
platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/data/BukkitBlockState.java
View File

@@ -25,24 +25,6 @@ public class BukkitBlockState implements BlockState {
}
public static BukkitBlockState newInstance(org.bukkit.block.data.BlockData bukkitData) {
if(bukkitData instanceof Rail) return new BukkitRail((Rail) bukkitData);
if(bukkitData instanceof Stairs) return new BukkitStairs((Stairs) bukkitData);
if(bukkitData instanceof Slab) return new BukkitSlab((Slab) bukkitData);
if(TerraBukkitPlugin.BUKKIT_VERSION.above(TerraBukkitPlugin.BukkitVersion.V1_16) && bukkitData instanceof Wall) { // Wall only exists on 1.16 and up.
return new BukkitWall((Wall) bukkitData);
}
if(bukkitData instanceof RedstoneWire) return new BukkitRedstoneWire((RedstoneWire) bukkitData);
if(bukkitData instanceof AnaloguePowerable) return new BukkitAnaloguePowerable((AnaloguePowerable) bukkitData);
if(bukkitData instanceof MultipleFacing) return new BukkitMultipleFacing((MultipleFacing) bukkitData);
if(bukkitData instanceof Rotatable) return new BukkitRotatable((Rotatable) bukkitData);
if(bukkitData instanceof Directional) return new BukkitDirectional((Directional) bukkitData);
if(bukkitData instanceof Orientable) return new BukkitOrientable((Orientable) bukkitData);
if(bukkitData instanceof Waterlogged) return new BukkitWaterlogged((Waterlogged) bukkitData);
return new BukkitBlockState(bukkitData);
}

21
platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/data/BukkitDirectional.java
View File

@@ -1,21 +0,0 @@
package com.dfsek.terra.bukkit.world.block.data;
import com.dfsek.terra.api.block.BlockFace;
import com.dfsek.terra.api.block.data.Directional;
import com.dfsek.terra.bukkit.world.BukkitAdapter;
public class BukkitDirectional extends BukkitBlockState implements Directional {
public BukkitDirectional(org.bukkit.block.data.Directional delegate) {
super(delegate);
}
@Override
public BlockFace getFacing() {
return BukkitAdapter.adapt(((org.bukkit.block.data.Directional) getHandle()).getFacing());
}
@Override
public void setFacing(BlockFace facing) {
((org.bukkit.block.data.Directional) getHandle()).setFacing(BukkitAdapter.adapt(facing));
}
}

35
platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/data/BukkitMultipleFacing.java
View File

@@ -1,35 +0,0 @@
package com.dfsek.terra.bukkit.world.block.data;
import com.dfsek.terra.api.block.BlockFace;
import com.dfsek.terra.api.block.data.MultipleFacing;
import com.dfsek.terra.bukkit.world.BukkitAdapter;
import java.util.Set;
import java.util.stream.Collectors;
public class BukkitMultipleFacing extends BukkitBlockState implements MultipleFacing {
public BukkitMultipleFacing(org.bukkit.block.data.MultipleFacing delegate) {
super(delegate);
}
@Override
public Set<BlockFace> getFaces() {
return ((org.bukkit.block.data.MultipleFacing) super.getHandle()).getFaces().stream().map(BukkitAdapter::adapt).collect(Collectors.toSet());
}
@Override
public void setFace(BlockFace face, boolean facing) {
((org.bukkit.block.data.MultipleFacing) super.getHandle()).setFace(BukkitAdapter.adapt(face), facing);
}
@Override
public Set<BlockFace> getAllowedFaces() {
return ((org.bukkit.block.data.MultipleFacing) super.getHandle()).getAllowedFaces().stream().map(BukkitAdapter::adapt).collect(Collectors.toSet());
}
@Override
public boolean hasFace(BlockFace f) {
return ((org.bukkit.block.data.MultipleFacing) super.getHandle()).hasFace(BukkitAdapter.adapt(f));
}
}

30
platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/data/BukkitOrientable.java
View File

@@ -1,30 +0,0 @@
package com.dfsek.terra.bukkit.world.block.data;
import com.dfsek.terra.api.block.state.properties.enums.Axis;
import com.dfsek.terra.api.block.data.Orientable;
import com.dfsek.terra.bukkit.world.BukkitAdapter;
import java.util.Set;
import java.util.stream.Collectors;
public class BukkitOrientable extends BukkitBlockState implements Orientable {
public BukkitOrientable(org.bukkit.block.data.Orientable delegate) {
super(delegate);
}
@Override
public Set<Axis> getAxes() {
return ((org.bukkit.block.data.Orientable) getHandle()).getAxes().stream().map(BukkitAdapter::adapt).collect(Collectors.toSet());
}
@Override
public Axis getAxis() {
return BukkitAdapter.adapt(((org.bukkit.block.data.Orientable) getHandle()).getAxis());
}
@Override
public void setAxis(Axis axis) {
((org.bukkit.block.data.Orientable) getHandle()).setAxis(BukkitAdapter.adapt(axis));
}
}

21
platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/data/BukkitRail.java
View File

@@ -1,21 +0,0 @@
package com.dfsek.terra.bukkit.world.block.data;
import com.dfsek.terra.api.block.data.Rail;
import com.dfsek.terra.api.block.state.properties.enums.RailShape;
import com.dfsek.terra.bukkit.world.BukkitAdapter;
public class BukkitRail extends BukkitBlockState implements Rail {
public BukkitRail(org.bukkit.block.data.Rail delegate) {
super(delegate);
}
@Override
public RailShape getShape() {
return BukkitAdapter.adapt(((org.bukkit.block.data.Rail) getHandle()).getShape());
}
@Override
public void setShape(RailShape newShape) {
((org.bukkit.block.data.Rail) getHandle()).setShape(BukkitAdapter.adapt(newShape));
}
}

29
platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/data/BukkitRedstoneWire.java
View File

@@ -1,29 +0,0 @@
package com.dfsek.terra.bukkit.world.block.data;
import com.dfsek.terra.api.block.BlockFace;
import com.dfsek.terra.api.block.data.RedstoneWire;
import com.dfsek.terra.bukkit.world.BukkitAdapter;
import java.util.Set;
import java.util.stream.Collectors;
public class BukkitRedstoneWire extends BukkitAnaloguePowerable implements RedstoneWire {
public BukkitRedstoneWire(org.bukkit.block.data.type.RedstoneWire delegate) {
super(delegate);
}
@Override
public Set<BlockFace> getAllowedFaces() {
return ((org.bukkit.block.data.type.RedstoneWire) getHandle()).getAllowedFaces().stream().map(BukkitAdapter::adapt).collect(Collectors.toSet());
}
@Override
public Connection getFace(BlockFace face) {
return BukkitAdapter.adapt(((org.bukkit.block.data.type.RedstoneWire) getHandle()).getFace(BukkitAdapter.adapt(face)));
}
@Override
public void setFace(BlockFace face, Connection connection) {
((org.bukkit.block.data.type.RedstoneWire) getHandle()).setFace(BukkitAdapter.adapt(face), BukkitAdapter.adapt(connection));
}
}

21
platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/data/BukkitRotatable.java
View File

@@ -1,21 +0,0 @@
package com.dfsek.terra.bukkit.world.block.data;
import com.dfsek.terra.api.block.BlockFace;
import com.dfsek.terra.api.block.data.Rotatable;
import com.dfsek.terra.bukkit.world.BukkitAdapter;
public class BukkitRotatable extends BukkitBlockState implements Rotatable {
public BukkitRotatable(org.bukkit.block.data.Rotatable delegate) {
super(delegate);
}
@Override
public BlockFace getRotation() {
return BukkitAdapter.adapt(((org.bukkit.block.data.Rotatable) getHandle()).getRotation());
}
@Override
public void setRotation(BlockFace face) {
((org.bukkit.block.data.Rotatable) getHandle()).setRotation(BukkitAdapter.adapt(face));
}
}

20
platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/data/BukkitSlab.java
View File

@@ -1,20 +0,0 @@
package com.dfsek.terra.bukkit.world.block.data;
import com.dfsek.terra.api.block.data.Slab;
import com.dfsek.terra.bukkit.world.BukkitAdapter;
public class BukkitSlab extends BukkitWaterlogged implements Slab {
public BukkitSlab(org.bukkit.block.data.type.Slab delegate) {
super(delegate);
}
@Override
public Type getType() {
return BukkitAdapter.adapt(((org.bukkit.block.data.type.Slab) getHandle()).getType());
}
@Override
public void setType(Type type) {
((org.bukkit.block.data.type.Slab) getHandle()).setType(BukkitAdapter.adapt(type));
}
}

52
platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/data/BukkitStairs.java
View File

@@ -1,52 +0,0 @@
package com.dfsek.terra.bukkit.world.block.data;
import com.dfsek.terra.api.block.BlockFace;
import com.dfsek.terra.api.block.data.Stairs;
import com.dfsek.terra.bukkit.world.BukkitAdapter;
public class BukkitStairs extends BukkitBlockState implements Stairs {
public BukkitStairs(org.bukkit.block.data.type.Stairs delegate) {
super(delegate);
}
@Override
public Shape getShape() {
return BukkitAdapter.adapt(((org.bukkit.block.data.type.Stairs) super.getHandle()).getShape());
}
@Override
public void setShape(Shape shape) {
((org.bukkit.block.data.type.Stairs) super.getHandle()).setShape(BukkitAdapter.adapt(shape));
}
@Override
public Half getHalf() {
return BukkitAdapter.adapt(((org.bukkit.block.data.type.Stairs) super.getHandle()).getHalf());
}
@Override
public void setHalf(Half half) {
((org.bukkit.block.data.type.Stairs) super.getHandle()).setHalf(BukkitAdapter.adapt(half));
}
@Override
public BlockFace getFacing() {
return BukkitAdapter.adapt(((org.bukkit.block.data.type.Stairs) super.getHandle()).getFacing());
}
@Override
public void setFacing(BlockFace facing) {
((org.bukkit.block.data.type.Stairs) super.getHandle()).setFacing(BukkitAdapter.adapt(facing));
}
@Override
public boolean isWaterlogged() {
return ((org.bukkit.block.data.type.Stairs) super.getHandle()).isWaterlogged();
}
@Override
public void setWaterlogged(boolean waterlogged) {
((org.bukkit.block.data.type.Stairs) super.getHandle()).setWaterlogged(waterlogged);
}
}

57
platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/data/BukkitWall.java
View File

@@ -1,57 +0,0 @@
package com.dfsek.terra.bukkit.world.block.data;
import com.dfsek.terra.api.block.BlockFace;
import com.dfsek.terra.api.block.data.Wall;
import com.dfsek.terra.bukkit.world.BukkitAdapter;
public class BukkitWall extends BukkitWaterlogged implements Wall {
public BukkitWall(org.bukkit.block.data.type.Wall delegate) {
super(delegate);
}
@Override
public boolean isUp() {
return ((org.bukkit.block.data.type.Wall) getHandle()).isUp();
}
@Override
public void setUp(boolean up) {
((org.bukkit.block.data.type.Wall) getHandle()).setUp(up);
}
public static org.bukkit.block.data.type.Wall.Height adapt(com.dfsek.terra.api.block.data.Wall.Height height) {
switch(height) {
case NONE:
return org.bukkit.block.data.type.Wall.Height.NONE;
case LOW:
return org.bukkit.block.data.type.Wall.Height.LOW;
case TALL:
return org.bukkit.block.data.type.Wall.Height.TALL;
default:
throw new IllegalStateException();
}
}
public static com.dfsek.terra.api.block.data.Wall.Height adapt(org.bukkit.block.data.type.Wall.Height height) {
switch(height) {
case TALL:
return com.dfsek.terra.api.block.data.Wall.Height.TALL;
case LOW:
return com.dfsek.terra.api.block.data.Wall.Height.LOW;
case NONE:
return com.dfsek.terra.api.block.data.Wall.Height.NONE;
default:
throw new IllegalStateException();
}
}
@Override
public void setHeight(BlockFace face, Height height) {
((org.bukkit.block.data.type.Wall) getHandle()).setHeight(BukkitAdapter.adapt(face), adapt(height));
}
@Override
public Height getHeight(BlockFace face) {
return adapt(((org.bukkit.block.data.type.Wall) getHandle()).getHeight(BukkitAdapter.adapt(face)));
}
}

19
platforms/bukkit/src/main/java/com/dfsek/terra/bukkit/world/block/data/BukkitWaterlogged.java
View File

@@ -1,19 +0,0 @@
package com.dfsek.terra.bukkit.world.block.data;
import com.dfsek.terra.api.block.data.Waterlogged;
public class BukkitWaterlogged extends BukkitBlockState implements Waterlogged {
public BukkitWaterlogged(org.bukkit.block.data.Waterlogged delegate) {
super(delegate);
}
@Override
public boolean isWaterlogged() {
return ((org.bukkit.block.data.Waterlogged) super.getHandle()).isWaterlogged();
}
@Override
public void setWaterlogged(boolean waterlogged) {
((org.bukkit.block.data.Waterlogged) super.getHandle()).setWaterlogged(waterlogged);
}
}

29
platforms/fabric/src/main/java/com/dfsek/terra/fabric/block/data/FabricAnaloguePowerable.java
View File

@@ -1,29 +0,0 @@
package com.dfsek.terra.fabric.block.data;
import com.dfsek.terra.api.block.data.AnaloguePowerable;
import com.dfsek.terra.fabric.block.FabricBlockState;
import net.minecraft.block.BlockState;
/**
* None of this actually has implementation, TODO: implement this if we ever end up needing it.
*/
public class FabricAnaloguePowerable extends FabricBlockState implements AnaloguePowerable {
public FabricAnaloguePowerable(BlockState delegate) {
super(delegate);
}
@Override
public int getMaximumPower() {
return 0;
}
@Override
public int getPower() {
return 0;
}
@Override
public void setPower(int power) {
}
}

42
platforms/fabric/src/main/java/com/dfsek/terra/fabric/block/data/FabricDirectional.java
View File

@@ -1,42 +0,0 @@
package com.dfsek.terra.fabric.block.data;
import com.dfsek.terra.api.block.BlockFace;
import com.dfsek.terra.api.block.data.Directional;
import com.dfsek.terra.fabric.block.FabricBlockState;
import com.dfsek.terra.fabric.util.FabricAdapter;
import net.minecraft.block.BlockState;
import net.minecraft.state.property.DirectionProperty;
public class FabricDirectional extends FabricBlockState implements Directional {
private final DirectionProperty property;
public FabricDirectional(BlockState delegate, DirectionProperty property) {
super(delegate);
this.property = property;
}
@Override
public BlockFace getFacing() {
switch(delegate.get(property)) {
case SOUTH:
return BlockFace.SOUTH;
case DOWN:
return BlockFace.DOWN;
case UP:
return BlockFace.UP;
case EAST:
return BlockFace.EAST;
case WEST:
return BlockFace.WEST;
case NORTH:
return BlockFace.NORTH;
default:
throw new IllegalStateException();
}
}
@Override
public void setFacing(BlockFace facing) {
delegate = delegate.with(property, FabricAdapter.adapt(facing));
}
}

69
platforms/fabric/src/main/java/com/dfsek/terra/fabric/block/data/FabricMultipleFacing.java
View File

@@ -1,69 +0,0 @@
package com.dfsek.terra.fabric.block.data;
import com.dfsek.terra.api.block.BlockFace;
import com.dfsek.terra.api.block.data.MultipleFacing;
import com.dfsek.terra.fabric.block.FabricBlockState;
import net.minecraft.block.BlockState;
import net.minecraft.state.property.Properties;
import java.util.HashSet;
import java.util.Set;
public class FabricMultipleFacing extends FabricBlockState implements MultipleFacing {
public FabricMultipleFacing(BlockState delegate) {
super(delegate);
}
@Override
public Set<BlockFace> getFaces() {
Set<BlockFace> set = new HashSet<>();
if(delegate.get(Properties.NORTH)) set.add(BlockFace.NORTH);
if(delegate.get(Properties.SOUTH)) set.add(BlockFace.SOUTH);
if(delegate.get(Properties.EAST)) set.add(BlockFace.EAST);
if(delegate.get(Properties.WEST)) set.add(BlockFace.WEST);
if(delegate.contains(Properties.UP) && delegate.get(Properties.UP)) set.add(BlockFace.UP);
if(delegate.contains(Properties.DOWN) && delegate.get(Properties.DOWN)) set.add(BlockFace.DOWN);
return set;
}
@Override
public void setFace(BlockFace face, boolean facing) {
switch(face) {
case NORTH:
delegate = delegate.with(Properties.NORTH, facing);
break;
case SOUTH:
delegate = delegate.with(Properties.SOUTH, facing);
break;
case EAST:
delegate = delegate.with(Properties.EAST, facing);
break;
case WEST:
delegate = delegate.with(Properties.WEST, facing);
break;
case UP:
delegate = delegate.with(Properties.UP, facing);
break;
case DOWN:
delegate = delegate.with(Properties.DOWN, facing);
break;
}
}
@Override
public Set<BlockFace> getAllowedFaces() {
Set<BlockFace> set = new HashSet<>();
if(delegate.contains(Properties.NORTH)) set.add(BlockFace.NORTH);
if(delegate.contains(Properties.SOUTH)) set.add(BlockFace.SOUTH);
if(delegate.contains(Properties.EAST)) set.add(BlockFace.EAST);
if(delegate.contains(Properties.WEST)) set.add(BlockFace.WEST);
if(delegate.contains(Properties.UP)) set.add(BlockFace.UP);
if(delegate.contains(Properties.DOWN)) set.add(BlockFace.DOWN);
return set;
}
@Override
public boolean hasFace(BlockFace f) {
return getFaces().contains(f);
}
}

37
platforms/fabric/src/main/java/com/dfsek/terra/fabric/block/data/FabricOrientable.java
View File

@@ -1,37 +0,0 @@
package com.dfsek.terra.fabric.block.data;
import com.dfsek.terra.api.block.state.properties.enums.Axis;
import com.dfsek.terra.api.block.data.Orientable;
import com.dfsek.terra.fabric.block.FabricBlockState;
import com.dfsek.terra.fabric.util.FabricAdapter;
import net.minecraft.block.BlockState;
import net.minecraft.state.property.EnumProperty;
import net.minecraft.util.math.Direction;
import java.util.Arrays;
import java.util.Set;
import java.util.stream.Collectors;
public class FabricOrientable extends FabricBlockState implements Orientable {
private final EnumProperty<Direction.Axis> property;
public FabricOrientable(BlockState delegate, EnumProperty<Direction.Axis> property) {
super(delegate);
this.property = property;
}
@Override
public Set<Axis> getAxes() {
return Arrays.stream(Axis.values()).collect(Collectors.toSet());
}
@Override
public Axis getAxis() {
return FabricAdapter.adapt(getHandle().get(property));
}
@Override
public void setAxis(Axis axis) {
delegate = delegate.with(property, FabricAdapter.adapt(axis));
}
}

111
platforms/fabric/src/main/java/com/dfsek/terra/fabric/block/data/FabricRotatable.java
View File

@@ -1,111 +0,0 @@
package com.dfsek.terra.fabric.block.data;
import com.dfsek.terra.api.block.BlockFace;
import com.dfsek.terra.api.block.data.Rotatable;
import com.dfsek.terra.fabric.block.FabricBlockState;
import net.minecraft.block.BlockState;
import net.minecraft.state.property.Properties;
public class FabricRotatable extends FabricBlockState implements Rotatable {
public FabricRotatable(BlockState delegate) {
super(delegate);
}
@Override
public BlockFace getRotation() {
int r = delegate.get(Properties.ROTATION);
switch(r) {
case 0:
return BlockFace.SOUTH;
case 1:
return BlockFace.SOUTH_SOUTH_WEST;
case 2:
return BlockFace.SOUTH_WEST;
case 3:
return BlockFace.WEST_SOUTH_WEST;
case 4:
return BlockFace.WEST;
case 5:
return BlockFace.WEST_NORTH_WEST;
case 6:
return BlockFace.NORTH_WEST;
case 7:
return BlockFace.NORTH_NORTH_WEST;
case 8:
return BlockFace.NORTH;
case 9:
return BlockFace.NORTH_NORTH_EAST;
case 10:
return BlockFace.NORTH_EAST;
case 11:
return BlockFace.EAST_NORTH_EAST;
case 12:
return BlockFace.EAST;
case 13:
return BlockFace.EAST_SOUTH_EAST;
case 14:
return BlockFace.SOUTH_EAST;
case 15:
return BlockFace.SOUTH_SOUTH_EAST;
default:
throw new IllegalArgumentException("Unknown rotation " + r);
}
}
@Override
public void setRotation(BlockFace face) {
switch(face) {
case UP:
case DOWN:
throw new IllegalArgumentException("Illegal rotation " + face);
case SOUTH:
delegate = delegate.with(Properties.ROTATION, 0);
return;
case SOUTH_SOUTH_WEST:
delegate = delegate.with(Properties.ROTATION, 1);
return;
case SOUTH_WEST:
delegate = delegate.with(Properties.ROTATION, 2);
return;
case WEST_SOUTH_WEST:
delegate = delegate.with(Properties.ROTATION, 3);
return;
case WEST:
delegate = delegate.with(Properties.ROTATION, 4);
return;
case WEST_NORTH_WEST:
delegate = delegate.with(Properties.ROTATION, 5);
return;
case NORTH_WEST:
delegate = delegate.with(Properties.ROTATION, 6);
return;
case NORTH_NORTH_WEST:
delegate = delegate.with(Properties.ROTATION, 7);
return;
case NORTH:
delegate = delegate.with(Properties.ROTATION, 8);
return;
case NORTH_NORTH_EAST:
delegate = delegate.with(Properties.ROTATION, 9);
return;
case NORTH_EAST:
delegate = delegate.with(Properties.ROTATION, 10);
return;
case EAST_NORTH_EAST:
delegate = delegate.with(Properties.ROTATION, 11);
return;
case EAST:
delegate = delegate.with(Properties.ROTATION, 12);
return;
case EAST_SOUTH_EAST:
delegate = delegate.with(Properties.ROTATION, 13);
return;
case SOUTH_EAST:
delegate = delegate.with(Properties.ROTATION, 14);
return;
case SOUTH_SOUTH_EAST:
delegate = delegate.with(Properties.ROTATION, 15);
return;
}
}
}

22
platforms/fabric/src/main/java/com/dfsek/terra/fabric/block/data/FabricSlab.java
View File

@@ -1,22 +0,0 @@
package com.dfsek.terra.fabric.block.data;
import com.dfsek.terra.api.block.data.Slab;
import com.dfsek.terra.fabric.util.FabricAdapter;
import net.minecraft.block.BlockState;
import net.minecraft.state.property.Properties;
public class FabricSlab extends FabricWaterlogged implements Slab {
public FabricSlab(BlockState delegate) {
super(delegate);
}
@Override
public Type getType() {
return FabricAdapter.adapt(delegate.get(Properties.SLAB_TYPE));
}
@Override
public void setType(Type type) {
delegate = delegate.with(Properties.SLAB_TYPE, FabricAdapter.adapt(type));
}
}

43
platforms/fabric/src/main/java/com/dfsek/terra/fabric/block/data/FabricStairs.java
View File

@@ -1,43 +0,0 @@
package com.dfsek.terra.fabric.block.data;
import com.dfsek.terra.api.block.BlockFace;
import com.dfsek.terra.api.block.data.Stairs;
import com.dfsek.terra.fabric.util.FabricAdapter;
import net.minecraft.block.BlockState;
import net.minecraft.state.property.Properties;
public class FabricStairs extends FabricWaterlogged implements Stairs {
public FabricStairs(BlockState delegate) {
super(delegate);
}
@Override
public Shape getShape() {
return FabricAdapter.adapt(getHandle().get(Properties.STAIR_SHAPE));
}
@Override
public void setShape(Shape shape) {
super.delegate = getHandle().with(Properties.STAIR_SHAPE, FabricAdapter.adapt(shape));
}
@Override
public Half getHalf() {
return FabricAdapter.adapt(getHandle().get(Properties.BLOCK_HALF));
}
@Override
public void setHalf(Half half) {
super.delegate = getHandle().with(Properties.BLOCK_HALF, FabricAdapter.adapt(half));
}
@Override
public BlockFace getFacing() {
return FabricAdapter.adapt(getHandle().get(Properties.HORIZONTAL_FACING));
}
@Override
public void setFacing(BlockFace facing) {
super.delegate = getHandle().with(Properties.HORIZONTAL_FACING, FabricAdapter.adapt(facing));
}
}

22
platforms/fabric/src/main/java/com/dfsek/terra/fabric/block/data/FabricWaterlogged.java
View File

@@ -1,22 +0,0 @@
package com.dfsek.terra.fabric.block.data;
import com.dfsek.terra.api.block.data.Waterlogged;
import com.dfsek.terra.fabric.block.FabricBlockState;
import net.minecraft.block.BlockState;
import net.minecraft.state.property.Properties;
public class FabricWaterlogged extends FabricBlockState implements Waterlogged {
public FabricWaterlogged(BlockState delegate) {
super(delegate);
}
@Override
public boolean isWaterlogged() {
return delegate.get(Properties.WATERLOGGED);
}
@Override
public void setWaterlogged(boolean waterlogged) {
super.delegate = delegate.with(Properties.WATERLOGGED, waterlogged);
}
}

137
platforms/fabric/src/main/java/com/dfsek/terra/fabric/util/FabricAdapter.java
View File

@@ -1,30 +1,15 @@
package com.dfsek.terra.fabric.util;
import com.dfsek.terra.api.block.state.properties.enums.Half;
import com.dfsek.terra.api.block.state.properties.enums.Axis;
import com.dfsek.terra.api.block.BlockFace;
import com.dfsek.terra.api.block.data.Bisected;
import com.dfsek.terra.api.block.data.Slab;
import com.dfsek.terra.api.block.data.Stairs;
import com.dfsek.terra.api.vector.Vector3;
import com.dfsek.terra.fabric.block.FabricBlockState;
import com.dfsek.terra.fabric.block.data.FabricDirectional;
import com.dfsek.terra.fabric.block.data.FabricMultipleFacing;
import com.dfsek.terra.fabric.block.data.FabricOrientable;
import com.dfsek.terra.fabric.block.data.FabricRotatable;
import com.dfsek.terra.fabric.block.data.FabricSlab;
import com.dfsek.terra.fabric.block.data.FabricStairs;
import com.dfsek.terra.fabric.block.data.FabricWaterlogged;
import com.dfsek.terra.vector.Vector3Impl;
import net.minecraft.block.BlockState;
import net.minecraft.block.enums.BlockHalf;
import net.minecraft.block.enums.SlabType;
import net.minecraft.block.enums.StairShape;
import net.minecraft.state.property.Properties;
import net.minecraft.util.math.BlockPos;
import net.minecraft.util.math.Direction;
import java.util.Arrays;
public final class FabricAdapter {
public static BlockPos adapt(Vector3 v) {
return new BlockPos(v.getBlockX(), v.getBlockY(), v.getBlockZ());
@@ -35,122 +20,23 @@ public final class FabricAdapter {
}
public static FabricBlockState adapt(BlockState state) {
if(state.contains(Properties.STAIR_SHAPE)) return new FabricStairs(state);
if(state.contains(Properties.SLAB_TYPE)) return new FabricSlab(state);
if(state.contains(Properties.AXIS)) return new FabricOrientable(state, Properties.AXIS);
if(state.contains(Properties.HORIZONTAL_AXIS)) return new FabricOrientable(state, Properties.HORIZONTAL_AXIS);
if(state.contains(Properties.ROTATION)) return new FabricRotatable(state);
if(state.contains(Properties.FACING)) return new FabricDirectional(state, Properties.FACING);
if(state.contains(Properties.HOPPER_FACING)) return new FabricDirectional(state, Properties.HOPPER_FACING);
if(state.contains(Properties.HORIZONTAL_FACING)) return new FabricDirectional(state, Properties.HORIZONTAL_FACING);
if(state.getProperties().containsAll(Arrays.asList(Properties.NORTH, Properties.SOUTH, Properties.EAST, Properties.WEST)))
return new FabricMultipleFacing(state);
if(state.contains(Properties.WATERLOGGED)) return new FabricWaterlogged(state);
return new FabricBlockState(state);
}
public static Direction adapt(BlockFace face) {
switch(face) {
case NORTH:
return Direction.NORTH;
case WEST:
return Direction.WEST;
case SOUTH:
return Direction.SOUTH;
case EAST:
return Direction.EAST;
case UP:
return Direction.UP;
case DOWN:
return Direction.DOWN;
default:
throw new IllegalArgumentException("Illegal direction: " + face);
}
}
public static Stairs.Shape adapt(StairShape shape) {
switch(shape) {
case OUTER_RIGHT:
return Stairs.Shape.OUTER_RIGHT;
case INNER_RIGHT:
return Stairs.Shape.INNER_RIGHT;
case OUTER_LEFT:
return Stairs.Shape.OUTER_LEFT;
case INNER_LEFT:
return Stairs.Shape.INNER_LEFT;
case STRAIGHT:
return Stairs.Shape.STRAIGHT;
default:
throw new IllegalStateException();
}
}
public static Bisected.Half adapt(BlockHalf half) {
public static Half adapt(BlockHalf half) {
switch(half) {
case BOTTOM:
return Bisected.Half.BOTTOM;
return Half.BOTTOM;
case TOP:
return Bisected.Half.TOP;
return Half.TOP;
default:
throw new IllegalStateException();
}
}
public static BlockFace adapt(Direction direction) {
switch(direction) {
case DOWN:
return BlockFace.DOWN;
case UP:
return BlockFace.UP;
case WEST:
return BlockFace.WEST;
case EAST:
return BlockFace.EAST;
case NORTH:
return BlockFace.NORTH;
case SOUTH:
return BlockFace.SOUTH;
default:
throw new IllegalStateException();
}
}
public static Slab.Type adapt(SlabType type) {
switch(type) {
case BOTTOM:
return Slab.Type.BOTTOM;
case TOP:
return Slab.Type.TOP;
case DOUBLE:
return Slab.Type.DOUBLE;
default:
throw new IllegalStateException();
}
}
public static StairShape adapt(Stairs.Shape shape) {
switch(shape) {
case STRAIGHT:
return StairShape.STRAIGHT;
case INNER_LEFT:
return StairShape.INNER_LEFT;
case OUTER_LEFT:
return StairShape.OUTER_LEFT;
case INNER_RIGHT:
return StairShape.INNER_RIGHT;
case OUTER_RIGHT:
return StairShape.OUTER_RIGHT;
default:
throw new IllegalStateException();
}
}
public static BlockHalf adapt(Bisected.Half half) {
public static BlockHalf adapt(Half half) {
switch(half) {
case TOP:
return BlockHalf.TOP;
@@ -161,18 +47,7 @@ public final class FabricAdapter {
}
}
public static SlabType adapt(Slab.Type type) {
switch(type) {
case DOUBLE:
return SlabType.DOUBLE;
case TOP:
return SlabType.TOP;
case BOTTOM:
return SlabType.BOTTOM;
default:
throw new IllegalStateException();
}
}
public static Axis adapt(Direction.Axis axis) {
switch(axis) {