representables

src/main/java/net/krlite/knowledges/api/representable/BlockRepresentable.java

@@ -4,9 +4,12 @@
 import net.minecraft.block.BlockState;
 import net.minecraft.block.entity.BlockEntity;
 import net.minecraft.util.hit.BlockHitResult;
+import net.minecraft.util.hit.HitResult;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Direction;
 
+import java.util.function.Supplier;
+
 public interface BlockRepresentable extends Representable<BlockHitResult> {
     Block block();
 
@@ -16,38 +19,29 @@ public interface BlockRepresentable extends Representable<BlockHitResult> {
 
     BlockPos blockPos();
 
-    Direction direction();
+    Direction side();
 
     @Override
     default Class<? extends Representable<BlockHitResult>> type() {
         return BlockRepresentable.class;
     }
 
-    interface Builder extends Representable.Builder<BlockHitResult, BlockRepresentable> {
-        Builder block(Block block);
-
+    interface Builder extends Representable.Builder<BlockHitResult, BlockRepresentable, Builder> {
         Builder blockState(BlockState blockState);
 
-        Builder blockEntity(BlockEntity blockEntity);
-
-        Builder blockPos(BlockPos blockPos);
-
-        Builder direction(Direction direction);
+        default Builder blockEntity(BlockEntity blockEntity) {
+            return blockEntitySupplier(() -> blockEntity);
+        }
 
-        @Override
-        Builder create();
+        Builder blockEntitySupplier(Supplier<BlockEntity> blockEntitySupplier);
 
         @Override
         BlockRepresentable build();
 
-        @Override
-        default Builder from(BlockRepresentable representable) {
-            return ((Builder) Representable.Builder.super.from(representable))
-                    .block(representable.block())
+        static Builder append(Builder builder, BlockRepresentable representable) {
+            return Representable.Builder.append(builder, representable)
                     .blockState(representable.blockState())
-                    .blockEntity(representable.blockEntity())
-                    .blockPos(representable.blockPos())
-                    .direction(representable.direction());
+                    .blockEntity(representable.blockEntity());
         }
     }
 }

src/main/java/net/krlite/knowledges/api/representable/EntityRepresentable.java

@@ -3,6 +3,8 @@
 import net.minecraft.entity.Entity;
 import net.minecraft.util.hit.EntityHitResult;
 
+import java.util.function.Supplier;
+
 public interface EntityRepresentable extends Representable<EntityHitResult> {
     Entity entity();
 
@@ -11,18 +13,18 @@ default Class<? extends Representable<EntityHitResult>> type() {
         return EntityRepresentable.class;
     }
 
-    interface Builder extends Representable.Builder<EntityHitResult, EntityRepresentable> {
-        Builder entity(Entity entity);
+    interface Builder extends Representable.Builder<EntityHitResult, EntityRepresentable, Builder> {
+        default Builder entity(Entity entity) {
+            return entitySupplier(() -> entity);
+        }
 
-        @Override
-        Builder create();
+        Builder entitySupplier(Supplier<Entity> entitySupplier);
 
         @Override
         EntityRepresentable build();
 
-        @Override
-        default Builder from(EntityRepresentable representable) {
-            return ((Builder) Representable.Builder.super.from(representable))
+        static Builder append(Builder builder, EntityRepresentable representable) {
+            return Representable.Builder.append(builder, representable)
                     .entity(representable.entity());
         }
     }

src/main/java/net/krlite/knowledges/api/representable/Representable.java

@@ -21,23 +21,21 @@ public interface Representable<H extends HitResult> {
 
     Class<? extends Representable<H>> type();
 
-    interface Builder<H extends HitResult, R extends Representable<H>> {
-        Builder<H, R> hitResult(H hitResult);
+    interface Builder<H extends HitResult, R extends Representable<H>, B extends Builder<H, R, B>> {
+        B hitResult(H hitResult);
 
-        Builder<H, R> world(World world);
+        B world(World world);
 
-        Builder<H, R> player(PlayerEntity player);
+        B player(PlayerEntity player);
 
-        Builder<H, R> data(NbtCompound data);
+        B data(NbtCompound data);
 
-        Builder<H, R> hasServer(boolean connected);
+        B hasServer(boolean hasServer);
 
-        Builder<H, R> create();
+        R build();
 
-        Representable<H> build();
-
-        default Builder<H, R> from(R representable) {
-            return create()
+        static <H extends HitResult, R extends Representable<H>, B extends Builder<H, R, B>> B append(B builder, R representable) {
+            return builder
                     .hitResult(representable.hitResult())
                     .world(representable.world())
                     .player(representable.player())

src/main/java/net/krlite/knowledges/impl/representable/KnowledgesBlockRepresentable.java

@@ -0,0 +1,111 @@
+package net.krlite.knowledges.impl.representable;
+
+import net.krlite.knowledges.api.representable.BlockRepresentable;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.Blocks;
+import net.minecraft.block.entity.BlockEntity;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.nbt.NbtCompound;
+import net.minecraft.util.hit.BlockHitResult;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Direction;
+import net.minecraft.world.World;
+
+import java.util.function.Supplier;
+
+public class KnowledgesBlockRepresentable extends KnowledgesRepresentable<BlockHitResult> implements BlockRepresentable {
+    private final BlockState blockState;
+    private final Supplier<BlockEntity> blockEntitySupplier;
+
+    public KnowledgesBlockRepresentable(Builder builder) {
+        super(builder);
+        this.blockState = builder.blockState;
+        this.blockEntitySupplier = builder.blockEntitySupplier;
+    }
+
+    @Override
+    public Block block() {
+        return blockState.getBlock();
+    }
+
+    @Override
+    public BlockState blockState() {
+        return blockState;
+    }
+
+    @Override
+    public BlockEntity blockEntity() {
+        return blockEntitySupplier.get();
+    }
+
+    @Override
+    public BlockPos blockPos() {
+        return hitResult().getBlockPos();
+    }
+
+    @Override
+    public Direction side() {
+        return hitResult().getSide();
+    }
+
+    public static final class Builder extends KnowledgesRepresentable.Builder<BlockHitResult> implements BlockRepresentable.Builder {
+        private BlockState blockState = Blocks.AIR.getDefaultState();
+        private Supplier<BlockEntity> blockEntitySupplier;
+
+        @Override
+        public Builder hitResult(BlockHitResult hitResult) {
+            this.hitResult = hitResult;
+            return this;
+        }
+
+        @Override
+        public Builder world(World world) {
+            this.world = world;
+            return this;
+        }
+
+        @Override
+        public Builder player(PlayerEntity player) {
+            this.player = player;
+            return this;
+        }
+
+        @Override
+        public Builder data(NbtCompound data) {
+            this.data = data;
+            return this;
+        }
+
+        @Override
+        public Builder hasServer(boolean hasServer) {
+            this.hasServer = hasServer;
+            return this;
+        }
+
+        @Override
+        public Builder blockState(BlockState blockState) {
+            this.blockState = blockState;
+            return this;
+        }
+
+        @Override
+        public Builder blockEntitySupplier(Supplier<BlockEntity> blockEntitySupplier) {
+            this.blockEntitySupplier = blockEntitySupplier;
+            return this;
+        }
+
+        @Override
+        public KnowledgesBlockRepresentable build() {
+            return new KnowledgesBlockRepresentable(this);
+        }
+
+        public static Builder create() {
+            return new Builder();
+        }
+
+        public static Builder from(BlockRepresentable representable) {
+            return (Builder) BlockRepresentable.Builder.append(create(), representable);
+        }
+    }
+}

src/main/java/net/krlite/knowledges/impl/representable/KnowledgesEntityRepresentable.java

@@ -0,0 +1,77 @@
+package net.krlite.knowledges.impl.representable;
+
+import net.krlite.knowledges.api.representable.EntityRepresentable;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.nbt.NbtCompound;
+import net.minecraft.util.hit.EntityHitResult;
+import net.minecraft.world.World;
+
+import java.util.function.Supplier;
+
+public class KnowledgesEntityRepresentable extends KnowledgesRepresentable<EntityHitResult> implements EntityRepresentable {
+    private final Supplier<Entity> entitySupplier;
+
+    public KnowledgesEntityRepresentable(Builder builder) {
+        super(builder);
+        this.entitySupplier = builder.entitySupplier;
+    }
+
+    @Override
+    public Entity entity() {
+        return entitySupplier.get();
+    }
+
+    public static class Builder extends KnowledgesRepresentable.Builder<EntityHitResult> implements EntityRepresentable.Builder {
+        private Supplier<Entity> entitySupplier;
+
+        @Override
+        public Builder entitySupplier(Supplier<Entity> entitySupplier) {
+            this.entitySupplier = entitySupplier;
+            return this;
+        }
+
+        @Override
+        public Builder hitResult(EntityHitResult hitResult) {
+            this.hitResult = hitResult;
+            return this;
+        }
+
+        @Override
+        public Builder world(World world) {
+            this.world = world;
+            return this;
+        }
+
+        @Override
+        public Builder player(PlayerEntity player) {
+            this.player = player;
+            return this;
+        }
+
+        @Override
+        public Builder data(NbtCompound data) {
+            this.data = data;
+            return this;
+        }
+
+        @Override
+        public Builder hasServer(boolean hasServer) {
+            this.hasServer = hasServer;
+            return this;
+        }
+
+        @Override
+        public EntityRepresentable build() {
+            return new KnowledgesEntityRepresentable(this);
+        }
+
+        public static Builder create() {
+            return new Builder();
+        }
+
+        public static Builder from(EntityRepresentable representable) {
+            return (Builder) EntityRepresentable.Builder.append(create(), representable);
+        }
+    }
+}

src/main/java/net/krlite/knowledges/impl/representable/KnowledgesRepresentable.java

@@ -0,0 +1,62 @@
+package net.krlite.knowledges.impl.representable;
+
+import net.krlite.knowledges.api.representable.Representable;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.nbt.NbtCompound;
+import net.minecraft.util.hit.HitResult;
+import net.minecraft.world.World;
+
+import java.util.function.Supplier;
+
+public abstract class KnowledgesRepresentable<H extends HitResult> implements Representable<H> {
+    private final Supplier<H> hitResultSupplier;
+    private final World world;
+    private final PlayerEntity player;
+    private final NbtCompound data;
+    private final boolean hasServer;
+
+    protected KnowledgesRepresentable(Supplier<H> hitResultSupplier, World world, PlayerEntity player, NbtCompound data, boolean hasServer) {
+        this.hitResultSupplier = hitResultSupplier;
+        this.world = world;
+        this.player = player;
+        this.data = data;
+        this.hasServer = hasServer;
+    }
+
+    protected <B extends Builder<H>> KnowledgesRepresentable(B builder) {
+        this(() -> builder.hitResult, builder.world, builder.player, builder.data, builder.hasServer);
+    }
+
+    @Override
+    public H hitResult() {
+        return hitResultSupplier.get();
+    }
+
+    @Override
+    public World world() {
+        return world;
+    }
+
+    @Override
+    public PlayerEntity player() {
+        return player;
+    }
+
+    @Override
+    public NbtCompound data() {
+        return data;
+    }
+
+    @Override
+    public boolean hasServer() {
+        return hasServer;
+    }
+
+    public static class Builder<H extends HitResult> {
+        protected H hitResult;
+        protected World world;
+        protected PlayerEntity player;
+        protected NbtCompound data;
+        protected boolean hasServer;
+    }
+}