Update 'README.md'

notification that this mod will die

README.md

@@ -1,8 +1,12 @@
 # Glowstone Wire
 
 Adds redstone-like dust for glowstone.
-- Emit's light level 9 (Perfect for 2-wide path ways)
-- Is thinner then redstone
+- Emit's light level 8 (Perfect for 2-wide path ways)
 - Can be customized to look a little more stylized
 
-10/10, great mod.
+10/10, great mod.
+
+===================
+
+This mod will not see any further updates,
+And I urge you to look at Wired Dust by myself.

build.gradle

@@ -16,6 +16,7 @@ repositories {
 	// Loom adds the essential maven repositories to download Minecraft and libraries from automatically.
 	// See https://docs.gradle.org/current/userguide/declaring_repositories.html
 	// for more information about repositories.
+	maven{url "https://maven.shedaniel.me/"}
 }
 
 dependencies {
@@ -27,6 +28,11 @@ dependencies {
 	// Fabric API. This is technically optional, but you probably want it anyway.
 	modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}"
 
+	// Custom API's
+	modApi ("me.shedaniel.cloth:cloth-config-fabric:4.11.26") {
+		exclude(group: "net.fabricmc.fabric-api")
+	}
+
 	// PSA: Some older mods, compiled on Loom 0.2.1, might have outdated Maven POMs.
 	// You may need to force-disable transitiveness on them.
 }

gradle.properties

@@ -8,9 +8,9 @@ org.gradle.jvmargs=-Xmx1G
 	loader_version=0.11.3
 
 # Mod Properties
-	mod_version = 0.0.1
+	mod_version = 1.0.0
 	maven_group = me.parsell
-	archives_base_name = glowstonedust
+	archives_base_name = glowstonewire
 
 # Dependencies
 	# currently not on the main fabric site, check on the maven: https://maven.fabricmc.net/net/fabricmc/fabric-api/fabric-api

src/main/java/me/parsell/glowstonewire/GlowstoneWire.java

@@ -2,17 +2,24 @@ package me.parsell.glowstonewire;
 
 import me.parsell.glowstonewire.core.glowBlocks;
 import me.parsell.glowstonewire.core.glowItems;
+import me.parsell.glowstonewire.core.glowLootTables;
+import me.parsell.glowstonewire.core.glowRecipes;
+import me.shedaniel.autoconfig.AutoConfig;
+import me.shedaniel.autoconfig.serializer.GsonConfigSerializer;
 import net.fabricmc.api.ModInitializer;
 
 public class GlowstoneWire implements ModInitializer {
+	public static final String MODID = "glowstonewire";
+	public static GlowstoneWireConfig CONFIG;
+	
 	@Override
 	public void onInitialize() {
-		// This code runs as soon as Minecraft is in a mod-load-ready state.
-		// However, some things (like resources) may still be uninitialized.
-		// Proceed with mild caution.
+		AutoConfig.register(GlowstoneWireConfig.class, GsonConfigSerializer::new);
+		CONFIG = AutoConfig.getConfigHolder(GlowstoneWireConfig.class).getConfig();
 
-		System.out.println("Hello Fabric world!");
-    glowBlocks.init();
-    glowItems.init();
+    	glowBlocks.init();
+    	glowItems.init();
+		glowRecipes.init();
+		glowLootTables.init();
 	}
 }

src/main/java/me/parsell/glowstonewire/GlowstoneWireClient.java

@@ -10,8 +10,6 @@ public class GlowstoneWireClient implements ClientModInitializer {
 	@Override
 	public void onInitializeClient(){
     BlockRenderLayerMap.INSTANCE.putBlock(glowBlocks.GLOWSTONEWIRE, RenderLayer.getCutout());
-    ColorProviderRegistry.BLOCK.register((state, world, pos, tintIndex) -> {
-			return 0xFFFF00;
-		 }, glowBlocks.GLOWSTONEWIRE);
+    ColorProviderRegistry.BLOCK.register((state, world, pos, tintIndex) -> {return 0xffbc5e;}, glowBlocks.GLOWSTONEWIRE);
 	}
 }

src/main/java/me/parsell/glowstonewire/GlowstoneWireConfig.java

@@ -0,0 +1,11 @@
+package me.parsell.glowstonewire;
+
+import me.shedaniel.autoconfig.ConfigData;
+import me.shedaniel.autoconfig.annotation.Config;
+
+@Config(name = "GlowstoneWire")
+public class GlowstoneWireConfig implements ConfigData{
+    public String Description = "Changing this does nothing. Replacing glowstone drops is dirty, and will overwrite ALL loot tables that attempt to change minecraft's glowstone loot table. Disable this, and cocnsider using a datapack to achieve what you want.";
+    public boolean addConversionRecipes = true;
+    public boolean replaceGlowstoneDrop = true;
+}

src/main/java/me/parsell/glowstonewire/common/GlowWireConnection.java

@@ -0,0 +1,36 @@
+package me.parsell.glowstonewire.common;
+
+import net.minecraft.util.StringIdentifiable;
+
+public enum GlowWireConnection implements StringIdentifiable{
+  UP("up"),
+  SIDE("side"),
+  BROKE("broke"),
+  NONE("none");
+
+  private final String name;
+
+  private GlowWireConnection(String name){
+    this.name = name;
+  }
+
+  public String toString() {
+    return this.asString();
+  }
+
+ public String asString() {
+    return this.name;
+  }
+
+  public boolean isBroken() {
+    return this == BROKE;
+  }
+
+ public boolean isConnected() {
+    return this != NONE && this != BROKE;
+  }
+
+  public boolean isConnectedUp(){
+    return this == UP;
+  }
+}

src/main/java/me/parsell/glowstonewire/common/GlowstoneWireBlock.java

@@ -4,17 +4,22 @@ import java.util.Map;
 
 import com.google.common.collect.ImmutableMap;
 import com.google.common.collect.Maps;
+import com.google.common.collect.UnmodifiableIterator;
+
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Iterator;
 
 import net.minecraft.block.Block;
 import net.minecraft.block.BlockState;
-import net.minecraft.block.Blocks;
 import net.minecraft.block.ShapeContext;
-import net.minecraft.block.enums.WireConnection;
+import net.minecraft.entity.EquipmentSlot;
+import net.minecraft.entity.LivingEntity;
 import net.minecraft.entity.player.PlayerEntity;
 import net.minecraft.item.ItemPlacementContext;
+import net.minecraft.item.ItemStack;
 import net.minecraft.state.StateManager;
 import net.minecraft.state.property.EnumProperty;
-import net.minecraft.state.property.Properties;
 import net.minecraft.util.ActionResult;
 import net.minecraft.util.BlockMirror;
 import net.minecraft.util.BlockRotation;
@@ -23,58 +28,105 @@ import net.minecraft.util.hit.BlockHitResult;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Direction;
 import net.minecraft.util.shape.VoxelShape;
+import net.minecraft.util.shape.VoxelShapes;
 import net.minecraft.world.BlockView;
 import net.minecraft.world.World;
+import net.minecraft.world.WorldAccess;
 import net.minecraft.world.WorldView;
 
 public class GlowstoneWireBlock extends Block{
 	// These are the states of the wires coming off our block
-	public static final net.minecraft.state.property.EnumProperty<net.minecraft.block.enums.WireConnection> WIRE_CONNECTION_NORTH;
-	public static final net.minecraft.state.property.EnumProperty<net.minecraft.block.enums.WireConnection> WIRE_CONNECTION_EAST;
-	public static final net.minecraft.state.property.EnumProperty<net.minecraft.block.enums.WireConnection> WIRE_CONNECTION_SOUTH;
-	public static final net.minecraft.state.property.EnumProperty<net.minecraft.block.enums.WireConnection> WIRE_CONNECTION_WEST;
+  public static final EnumProperty<GlowWireConnection> WIRE_CONNECTION_NORTH;
+  public static final EnumProperty<GlowWireConnection> WIRE_CONNECTION_SOUTH;
+  public static final EnumProperty<GlowWireConnection> WIRE_CONNECTION_EAST;
+  public static final EnumProperty<GlowWireConnection> WIRE_CONNECTION_WEST;
 
 	// Locally defined DIRECTION <-> WIRE_CONNECTION_DIRECTION
-	public static final Map<Direction, EnumProperty<WireConnection>> DIRECTION_TO_WIRE_CONNECTION_PROPERTY;
+	public static final Map<Direction, EnumProperty<GlowWireConnection>> DIRECTION_TO_WIRE_CONNECTION;
 
 	// Determines the hitbox for our block
-	public static final VoxelShape DOT_SHAPE;
+	public static final VoxelShape DOT_VOXELSHAPE;
+	private static final Map<Direction, VoxelShape> DIRECTION_HITBOX, UP_HITBOX;
+	private final Map<BlockState, VoxelShape> STATE_TO_VOXELSHAPE = Maps.newHashMap(); 
 
-	// Full sided state
-	private BlockState FULL_STATE;
 
 	public GlowstoneWireBlock(Settings settings) {
 		super(settings);
 		// Set these properties to be none as start, so we start with a dot
-		this.setDefaultState((BlockState)((BlockState)((BlockState)((BlockState)((BlockState)((BlockState)this.stateManager.getDefaultState()).with(WIRE_CONNECTION_NORTH, WireConnection.NONE)).with(WIRE_CONNECTION_EAST, WireConnection.NONE)).with(WIRE_CONNECTION_SOUTH, WireConnection.NONE)).with(WIRE_CONNECTION_WEST, WireConnection.NONE)));
-		this.FULL_STATE = (BlockState)((BlockState)((BlockState)((BlockState)this.getDefaultState().with(WIRE_CONNECTION_NORTH, WireConnection.SIDE)).with(WIRE_CONNECTION_EAST, WireConnection.SIDE)).with(WIRE_CONNECTION_SOUTH, WireConnection.SIDE)).with(WIRE_CONNECTION_WEST, WireConnection.SIDE);
+		this.setDefaultState((BlockState)((BlockState)((BlockState)((BlockState)((BlockState)((BlockState)this.stateManager.getDefaultState()).with(WIRE_CONNECTION_NORTH, GlowWireConnection.NONE)).with(WIRE_CONNECTION_EAST, GlowWireConnection.NONE)).with(WIRE_CONNECTION_SOUTH, GlowWireConnection.NONE)).with(WIRE_CONNECTION_WEST, GlowWireConnection.NONE)));
+		
+		UnmodifiableIterator stateItr = this.getStateManager().getStates().iterator();
+		while(stateItr.hasNext()) {
+			BlockState state = (BlockState)stateItr.next();
+			this.STATE_TO_VOXELSHAPE.put(state, determineVoxelShape(state));
+		}
 	}
 
 	// Make sure out block has the properties for us to manage
+	@Override
 	protected void appendProperties(StateManager.Builder<Block, BlockState> builder) {
 		builder.add(WIRE_CONNECTION_NORTH, WIRE_CONNECTION_EAST, WIRE_CONNECTION_SOUTH, WIRE_CONNECTION_WEST);
 	}
 
-	private static boolean isFullyConnected(BlockState state) {
-		return ((WireConnection)state.get(WIRE_CONNECTION_NORTH)).isConnected() && 
-					 ((WireConnection)state.get(WIRE_CONNECTION_SOUTH)).isConnected() && 
-					 ((WireConnection)state.get(WIRE_CONNECTION_EAST)).isConnected() && 
-					 ((WireConnection)state.get(WIRE_CONNECTION_WEST)).isConnected();
+	private static boolean hasConnection(BlockState state) {
+		return ((GlowWireConnection)state.get(WIRE_CONNECTION_NORTH)).isConnected() || 
+				((GlowWireConnection)state.get(WIRE_CONNECTION_SOUTH)).isConnected() ||
+				((GlowWireConnection)state.get(WIRE_CONNECTION_EAST)).isConnected() ||
+				((GlowWireConnection)state.get(WIRE_CONNECTION_WEST)).isConnected();
 	}
 
-	private static boolean isNotConnected(BlockState state) {
-		return !((WireConnection)state.get(WIRE_CONNECTION_NORTH)).isConnected() && 
-					 !((WireConnection)state.get(WIRE_CONNECTION_SOUTH)).isConnected() && 
-					 !((WireConnection)state.get(WIRE_CONNECTION_EAST)).isConnected() && 
-					 !((WireConnection)state.get(WIRE_CONNECTION_WEST)).isConnected();
+	private BlockState determineState(WorldAccess world, BlockState state, BlockPos pos){
+		Iterator<Direction> dirItr = Direction.Type.HORIZONTAL.iterator();
+		while(dirItr.hasNext()){
+			Direction dir = dirItr.next();
+			state = state.with(DIRECTION_TO_WIRE_CONNECTION.get(dir), determineConnection(world, pos, dir));
+		}
+		return state;
 	}
 
+	private GlowWireConnection determineConnection(WorldAccess world, BlockPos pos, Direction direction){
+		BlockPos offsetPos = pos.offset(direction);
+		if((world.getBlockState(offsetPos.up()).isOf(this) && world.isAir(pos.up()))) // If offset+up is me && if up is air
+			if(!world.getBlockState(offsetPos.up()).get(DIRECTION_TO_WIRE_CONNECTION.get(direction.getOpposite())).isBroken()) //if offset+up is not broken
+				if(world.getBlockState(offsetPos).hasSidedTransparency())	
+					return GlowWireConnection.SIDE;
+				else	
+					return GlowWireConnection.UP;
+		if(world.getBlockState(offsetPos.down()).isOf(this) && world.isAir(offsetPos)) // if offset+down is me && if offset is air
+			if(!world.getBlockState(offsetPos.down()).get(DIRECTION_TO_WIRE_CONNECTION.get(direction.getOpposite())).isBroken()) //if offset+down is not broken
+				return GlowWireConnection.SIDE;		
+		if(world.getBlockState(offsetPos).isOf(this)) // if offset is me
+			if(!world.getBlockState(offsetPos).get(DIRECTION_TO_WIRE_CONNECTION.get(direction.getOpposite())).isBroken()) // if offset is not broken
+				return GlowWireConnection.SIDE;
+		return GlowWireConnection.NONE;
+	}
+
+	@Override
 	public VoxelShape getOutlineShape(BlockState state, BlockView world, BlockPos pos, ShapeContext context) {
-		return DOT_SHAPE;
+		return STATE_TO_VOXELSHAPE.get(state);
 	}
 
-	public BlockState getPlacecmentState(ItemPlacementContext ctx){
-		return this.getDefaultState();
+	public VoxelShape determineVoxelShape(BlockState state){
+		VoxelShape voxelShape = DOT_VOXELSHAPE;
+
+		Iterator dirItr = Direction.Type.HORIZONTAL.iterator();
+		while(dirItr.hasNext()) {
+		   Direction direction = (Direction)dirItr.next();
+		   GlowWireConnection wireConnection = state.get(DIRECTION_TO_WIRE_CONNECTION.get(direction));
+		   if(state.equals(this.getDefaultState().with(DIRECTION_TO_WIRE_CONNECTION.get(direction), GlowWireConnection.SIDE))) {
+				voxelShape = VoxelShapes.union(voxelShape, (VoxelShape)DIRECTION_HITBOX.get(direction));
+				return VoxelShapes.union(voxelShape, DIRECTION_HITBOX.get(direction.getOpposite()));
+		   } else if (state.equals(this.getDefaultState().with(DIRECTION_TO_WIRE_CONNECTION.get(direction), GlowWireConnection.UP))) {
+				voxelShape = VoxelShapes.union(voxelShape, (VoxelShape)UP_HITBOX.get(direction));
+				return VoxelShapes.union(voxelShape, DIRECTION_HITBOX.get(direction.getOpposite()));
+		   } else if (wireConnection == GlowWireConnection.SIDE) {
+				voxelShape = VoxelShapes.union(voxelShape, (VoxelShape)DIRECTION_HITBOX.get(direction));
+		   } else if (wireConnection == GlowWireConnection.UP) {
+				voxelShape = VoxelShapes.union(voxelShape, (VoxelShape)UP_HITBOX.get(direction));
+		   }
+		}
+
+		return voxelShape;
 	}
 
 	public boolean canPlaceAt(BlockState state, WorldView world, BlockPos pos) {
@@ -84,9 +136,10 @@ public class GlowstoneWireBlock extends Block{
 	}
 
 	private boolean canRunOnTop(BlockView world, BlockPos pos, BlockState floor) {
-		return floor.isSideSolidFullSquare(world, pos, Direction.UP) || floor.isOf(Blocks.HOPPER);
+		return floor.isSideSolidFullSquare(world, pos, Direction.UP);
 	}
 
+	@Override
 	public BlockState rotate(BlockState state, BlockRotation rotation) {
 		switch(rotation) {
 		case CLOCKWISE_180:
@@ -98,9 +151,10 @@ public class GlowstoneWireBlock extends Block{
 		default:
 			 return state;
 		}
- }
+	}
 
- public BlockState mirror(BlockState state, BlockMirror mirror) {
+ 	@Override
+	 public BlockState mirror(BlockState state, BlockMirror mirror) {
 		switch(mirror) {
 		case LEFT_RIGHT:
 			 return (BlockState)((BlockState)state.with(WIRE_CONNECTION_NORTH, state.get(WIRE_CONNECTION_SOUTH))).with(WIRE_CONNECTION_SOUTH, state.get(WIRE_CONNECTION_NORTH));
@@ -109,60 +163,92 @@ public class GlowstoneWireBlock extends Block{
 		default:
 			 return super.mirror(state, mirror);
 		}
- }
+	}
 
+	// Place block check disconnect (if block block connection)
+ 	@Override // For each link, set to break and update the blocks around me (above and below)
 	public ActionResult onUse(BlockState state, World world, BlockPos pos, PlayerEntity player, Hand hand, BlockHitResult hit){
-		if(isNotConnected(state))
-			world.setBlockState(pos, FULL_STATE, 3);
-		else
-			world.setBlockState(pos, this.getDefaultState(), 3);
-		System.out.println("onUse");
-		return ActionResult.SUCCESS;
-	}
-
-	public void update(World world, BlockPos pos, BlockState state){
-		System.out.println("Update");
-		
-	}
-
-	// Check if I'm this,
-	// then update all my neighbors
-	// then tell my neighbors to update all their neighbors (why?)
-	public void updateNeighbors(World world, BlockPos pos){
-		if (world.getBlockState(pos).isOf(this)) {
-			world.updateNeighborsAlways(pos, this);
-			//Direction[] d = Direction.values();
-			//int dl = d.length;
-
-			//for(int i = 0; i < dl; ++i) {
-			//	 Direction direction = d[i];
-			//	 world.updateNeighborsAlways(pos.offset(direction), this);
-			//}
-
-	 }
-	}
-
-	public void neighborUpdate(BlockState state, World world, BlockPos pos, Block block, BlockPos fromPos, boolean notify){
-		if (!world.isClient) {
-			if (state.canPlaceAt(world, pos)) {
-				 this.update(world, pos, state);
-			} else {
-				 dropStacks(state, world, pos);
-				 world.removeBlock(pos, false);
+		if(player.abilities.allowModifyWorld)
+			if(hasConnection(state) && !player.hasStackEquipped(EquipmentSlot.MAINHAND)) {
+				Iterator<Direction> dirItr = Direction.Type.HORIZONTAL.iterator();
+				while(dirItr.hasNext()){
+					Direction dir = dirItr.next();
+					if(state.get(DIRECTION_TO_WIRE_CONNECTION.get(dir)).isConnected())
+						state = state.with(DIRECTION_TO_WIRE_CONNECTION.get(dir), GlowWireConnection.BROKE);
+				}
+				world.setBlockState(pos, state);
+				// These call neighborUpdate not getStateForNeighborUpdate!!
+				//world.updateNeighborsAlways(pos, this); // Update those around me
+				world.updateNeighbors(pos.down(), this); // Update those below me
+				world.updateNeighbors(pos.up(), this); // Update those above me
+				return ActionResult.SUCCESS;
 			}
+		return ActionResult.PASS;
+	}
 
-	 }
+	@Override // Get the state I should place in, and update those around me (above/below) as needed
+	public BlockState getPlacementState(ItemPlacementContext ctx){
+		return determineState(ctx.getWorld(), this.getDefaultState(), ctx.getBlockPos());
+	}
+
+	@Override
+	public void onPlaced(World world, BlockPos pos, BlockState state, @Nullable LivingEntity placer, ItemStack itemStack) {
+		world.updateNeighbors(pos.offset(Direction.UP), state.getBlock());
+		world.updateNeighbors(pos.offset(Direction.DOWN), state.getBlock());
+	}
+
+	@Override // This causes w/e issue that tracks deal with.
+	public void onBroken(WorldAccess world, BlockPos pos, BlockState state) {
+		world.updateNeighbors(pos.offset(Direction.UP), state.getBlock());
+		world.updateNeighbors(pos.offset(Direction.DOWN), state.getBlock());
+	}
+
+	@Override // Called when I get told to update, so I should see what/why I need to update. I also use this to determine if I need to be drop or not.
+	public void neighborUpdate(BlockState state, World world, BlockPos pos, Block block, BlockPos fromPos, boolean notify) {
+		if (!world.isClient) {
+			if(!state.canPlaceAt(world, pos)) {
+				dropStacks(state, world, pos);
+				world.removeBlock(pos, false);
+				this.onBroken(world, pos, state);
+			} else {
+				Iterator<Direction> dirItr = Direction.Type.HORIZONTAL.iterator();
+				while(dirItr.hasNext()){
+					Direction dir = dirItr.next();
+					if(!state.get(DIRECTION_TO_WIRE_CONNECTION.get(dir)).isBroken())
+						state = state.with(DIRECTION_TO_WIRE_CONNECTION.get(dir), determineConnection(world, pos, dir));
+				}
+				world.setBlockState(pos, state);
+			}
+		}
 	}
 
 	static {
-		WIRE_CONNECTION_NORTH = Properties.NORTH_WIRE_CONNECTION;
-		WIRE_CONNECTION_EAST = Properties.EAST_WIRE_CONNECTION;
-		WIRE_CONNECTION_SOUTH = Properties.SOUTH_WIRE_CONNECTION;
-		WIRE_CONNECTION_WEST = Properties.WEST_WIRE_CONNECTION;
+		WIRE_CONNECTION_NORTH = EnumProperty.of("north", GlowWireConnection.class);
+		WIRE_CONNECTION_EAST = EnumProperty.of("east", GlowWireConnection.class);
+		WIRE_CONNECTION_SOUTH = EnumProperty.of("south", GlowWireConnection.class);
+		WIRE_CONNECTION_WEST = EnumProperty.of("west", GlowWireConnection.class);
 		
-		DIRECTION_TO_WIRE_CONNECTION_PROPERTY = Maps.newEnumMap((Map)ImmutableMap.of(Direction.NORTH, WIRE_CONNECTION_NORTH, Direction.EAST, WIRE_CONNECTION_EAST, Direction.SOUTH, WIRE_CONNECTION_SOUTH, Direction.WEST, WIRE_CONNECTION_WEST));
+		DIRECTION_TO_WIRE_CONNECTION = Maps.newEnumMap((Map)ImmutableMap.of(
+			Direction.NORTH, WIRE_CONNECTION_NORTH, 
+			Direction.EAST, WIRE_CONNECTION_EAST, 
+			Direction.SOUTH, WIRE_CONNECTION_SOUTH, 
+			Direction.WEST, WIRE_CONNECTION_WEST)
+		);
 		
-		DOT_SHAPE = Block.createCuboidShape(3.0D, 0.0D, 3.0D, 13.0D, 1.0D, 13.0D);
+		DOT_VOXELSHAPE = Block.createCuboidShape(3.0D, 0.0D, 3.0D, 13.0D, 1.0D, 13.0D);
 
+		DIRECTION_HITBOX = Maps.newEnumMap((Map)ImmutableMap.of(
+			Direction.NORTH, Block.createCuboidShape(3.0D, 0.0D, 0.0D, 13.0D, 1.0D, 13.0D), 
+			Direction.SOUTH, Block.createCuboidShape(3.0D, 0.0D, 3.0D, 13.0D, 1.0D, 16.0D), 
+			Direction.EAST, Block.createCuboidShape(3.0D, 0.0D, 3.0D, 16.0D, 1.0D, 13.0D), 
+			Direction.WEST, Block.createCuboidShape(0.0D, 0.0D, 3.0D, 13.0D, 1.0D, 13.0D))
+		);
+
+		UP_HITBOX = Maps.newEnumMap((Map)ImmutableMap.of(
+			Direction.NORTH, VoxelShapes.union((VoxelShape)DIRECTION_HITBOX.get(Direction.NORTH), Block.createCuboidShape(3.0D, 0.0D, 0.0D, 13.0D, 16.0D, 1.0D)), 
+			Direction.SOUTH, VoxelShapes.union((VoxelShape)DIRECTION_HITBOX.get(Direction.SOUTH), Block.createCuboidShape(3.0D, 0.0D, 15.0D, 13.0D, 16.0D, 16.0D)), 
+			Direction.EAST, VoxelShapes.union((VoxelShape)DIRECTION_HITBOX.get(Direction.EAST), Block.createCuboidShape(15.0D, 0.0D, 3.0D, 16.0D, 16.0D, 13.0D)), 
+			Direction.WEST, VoxelShapes.union((VoxelShape)DIRECTION_HITBOX.get(Direction.WEST), Block.createCuboidShape(0.0D, 0.0D, 3.0D, 1.0D, 16.0D, 13.0D)))
+		); 
 	}
 }

src/main/java/me/parsell/glowstonewire/core/glowBlocks.java

@@ -1,5 +1,6 @@
 package me.parsell.glowstonewire.core;
 
+import me.parsell.glowstonewire.GlowstoneWire;
 import me.parsell.glowstonewire.common.GlowstoneWireBlock;
 import net.fabricmc.fabric.api.object.builder.v1.block.FabricBlockSettings;
 import net.minecraft.block.Block;
@@ -11,7 +12,6 @@ public class glowBlocks {
   public static final Block GLOWSTONEWIRE = new GlowstoneWireBlock(FabricBlockSettings.of(Material.SUPPORTED).breakInstantly().noCollision().luminance(8));
 
   public static void init(){
-    Registry.register(Registry.BLOCK, new Identifier("glowstonewire", "glowstone_wire"), GLOWSTONEWIRE);
-    
+    Registry.register(Registry.BLOCK, new Identifier(GlowstoneWire.MODID, "glowstone_wire"), GLOWSTONEWIRE);
   }
 }

src/main/java/me/parsell/glowstonewire/core/glowItems.java

@@ -1,13 +1,23 @@
 package me.parsell.glowstonewire.core;
 
+import me.parsell.glowstonewire.GlowstoneWire;
+import me.parsell.glowstonewire.mixin.BrewingRecipeRegistryInvoker;
+import net.fabricmc.fabric.api.client.itemgroup.FabricItemGroupBuilder;
 import net.fabricmc.fabric.api.item.v1.FabricItemSettings;
 import net.minecraft.item.BlockItem;
+import net.minecraft.item.Item;
 import net.minecraft.item.ItemGroup;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.Items;
+import net.minecraft.potion.Potions;
 import net.minecraft.util.Identifier;
 import net.minecraft.util.registry.Registry;
 
 public class glowItems {
+  public static final ItemGroup GLOWSTONEWIRE_CTAB = FabricItemGroupBuilder.build(new Identifier(GlowstoneWire.MODID, "general"), () -> new ItemStack(Items.GLOWSTONE_DUST));
+  public static final Item GLOWSTONE_DUST = new BlockItem(glowBlocks.GLOWSTONEWIRE, new FabricItemSettings().group(GLOWSTONEWIRE_CTAB));
+
   public static void init(){
-    Registry.register(Registry.ITEM, new Identifier("glowstonewire", "glowstone_wire"), new BlockItem(glowBlocks.GLOWSTONEWIRE, new FabricItemSettings().group(ItemGroup.MISC)));
-  };
+    Registry.register(Registry.ITEM, new Identifier(GlowstoneWire.MODID, "glowstone_dust"), GLOWSTONE_DUST);
+  }
 }

src/main/java/me/parsell/glowstonewire/core/glowLootTables.java

@@ -0,0 +1,125 @@
+package me.parsell.glowstonewire.core;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+
+import me.parsell.glowstonewire.GlowstoneWire;
+
+public class glowLootTables {
+    public static JsonObject glowstonelootTable;
+
+    public static void init(){
+      if(GlowstoneWire.CONFIG.replaceGlowstoneDrop) {
+        JsonObject explosion;
+        JsonObject limitValues, limit;
+        JsonObject bonus, parametersValues;
+        JsonObject count, countValues;
+        JsonArray secondItemArray;
+        JsonObject secondItem;
+    
+        JsonObject levelsValues, silktouch;
+        JsonArray enchantmentsArray;
+        JsonObject enchantments, match;
+        JsonArray firstItemArray;
+        JsonObject firstItem;
+    
+        JsonArray alternativesArray;
+        JsonObject alternatives;
+    
+        JsonArray rollsArray;
+        JsonObject rolls;
+    
+        JsonArray lootPoolsArray;
+
+        explosion = new JsonObject();
+        explosion.addProperty("function", "minecraft:explosion_decay");
+
+        limit = new JsonObject();
+        limit.addProperty("function", "minecraft:limit_count");
+        limitValues = new JsonObject();
+        limitValues.addProperty("max", 4);
+        limitValues.addProperty("min", 1);
+        limit.add("limit", limitValues);
+
+        bonus = new JsonObject();
+        bonus.addProperty("function", "minecraft:apply_bonus");
+        bonus.addProperty("enchantment", "minecraft:fortune");
+        bonus.addProperty("formula", "minecraft:uniform_bonus_count");
+        parametersValues = new JsonObject();
+        parametersValues.addProperty("bonusMultiplier", 1);
+        bonus.add("parameters", parametersValues);
+
+        count = new JsonObject();
+        count.addProperty("function", "minecraft:set_count");
+        countValues = new JsonObject();
+        countValues.addProperty("min", 2.0);
+        countValues.addProperty("max", 4.0);
+        countValues.addProperty("type", "minecraft:uniform");
+        count.add("count", countValues);
+
+        secondItemArray = new JsonArray();
+        secondItemArray.add(count);
+        secondItemArray.add(bonus);
+        secondItemArray.add(limit);
+        secondItemArray.add(explosion);
+
+        secondItem = new JsonObject();
+        secondItem.addProperty("type", "minecraft:item");
+        secondItem.add("functions", secondItemArray);
+        secondItem.addProperty("name", "glowstonewire:glowstone_dust");
+
+        //
+
+        levelsValues = new JsonObject();
+        levelsValues.addProperty("min", 1);
+        silktouch = new JsonObject();
+        silktouch.addProperty("enchantment", "minecraft:silk_touch");
+        silktouch.add("levels", levelsValues);
+
+        enchantmentsArray = new JsonArray();
+        enchantmentsArray.add(silktouch);
+        enchantments = new JsonObject();
+        enchantments.add("enchantments", enchantmentsArray);
+
+        match = new JsonObject();
+        match.addProperty("condition", "minecraft:match_tool");
+        match.add("predicate", enchantments);
+
+        firstItemArray = new JsonArray();
+        firstItemArray.add(match);
+        
+        firstItem = new JsonObject();
+        firstItem.addProperty("type", "minecraft:item");
+        firstItem.add("conditions", firstItemArray);
+        firstItem.addProperty("name", "minecraft:glowstone");
+
+        //
+
+        alternativesArray = new JsonArray();
+        alternativesArray.add(firstItem);
+        alternativesArray.add(secondItem);
+
+        alternatives = new JsonObject();
+        alternatives.addProperty("type", "minecraft:alternatives");
+        alternatives.add("children", alternativesArray);
+
+        //
+
+        rollsArray = new JsonArray();
+        rollsArray.add(alternatives);
+
+        rolls = new JsonObject();
+        rolls.addProperty("rolls", 1);
+        rolls.add("entries", rollsArray);
+
+        //
+
+        lootPoolsArray = new JsonArray();
+        lootPoolsArray.add(rolls);
+
+        glowstonelootTable = new JsonObject();
+        glowstonelootTable.addProperty("type", "minecraft:block");
+        glowstonelootTable.add("pools", lootPoolsArray);
+      }
+    }
+}

src/main/java/me/parsell/glowstonewire/core/glowRecipes.java

@@ -0,0 +1,66 @@
+package me.parsell.glowstonewire.core;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonObject;
+
+import me.parsell.glowstonewire.GlowstoneWire;
+import me.parsell.glowstonewire.mixin.BrewingRecipeRegistryInvoker;
+import me.parsell.glowstonewire.mixin.FireworkStarRecipeAccessor;
+import net.minecraft.item.Items;
+import net.minecraft.potion.Potions;
+import net.minecraft.recipe.Ingredient;
+
+public class glowRecipes {
+    public static JsonObject MODDED_TO_VANILLA;
+    public static JsonObject VANILLA_TO_MODDED;
+
+    public static void init(){
+        BrewingRecipeRegistryInvoker.registerPotionRecipe(Potions.WATER, glowItems.GLOWSTONE_DUST, Potions.THICK);
+        BrewingRecipeRegistryInvoker.registerPotionRecipe(Potions.LEAPING, glowItems.GLOWSTONE_DUST, Potions.STRONG_LEAPING);
+        BrewingRecipeRegistryInvoker.registerPotionRecipe(Potions.SLOWNESS, glowItems.GLOWSTONE_DUST, Potions.STRONG_SLOWNESS);
+        BrewingRecipeRegistryInvoker.registerPotionRecipe(Potions.TURTLE_MASTER, glowItems.GLOWSTONE_DUST, Potions.STRONG_TURTLE_MASTER);
+        BrewingRecipeRegistryInvoker.registerPotionRecipe(Potions.SWIFTNESS, glowItems.GLOWSTONE_DUST, Potions.STRONG_SWIFTNESS);
+        BrewingRecipeRegistryInvoker.registerPotionRecipe(Potions.HEALING, glowItems.GLOWSTONE_DUST, Potions.STRONG_HEALING);
+        BrewingRecipeRegistryInvoker.registerPotionRecipe(Potions.HARMING, glowItems.GLOWSTONE_DUST, Potions.STRONG_HARMING);
+        BrewingRecipeRegistryInvoker.registerPotionRecipe(Potions.POISON, glowItems.GLOWSTONE_DUST, Potions.STRONG_POISON);
+        BrewingRecipeRegistryInvoker.registerPotionRecipe(Potions.REGENERATION, glowItems.GLOWSTONE_DUST, Potions.STRONG_REGENERATION);
+        BrewingRecipeRegistryInvoker.registerPotionRecipe(Potions.STRENGTH, glowItems.GLOWSTONE_DUST, Potions.STRONG_STRENGTH);
+
+        // Manually reset the glowstone compability, since i cant find a way to read and reset.
+        Ingredient defaultFSFlickerModifier = FireworkStarRecipeAccessor.getFlickerModifier();
+        FireworkStarRecipeAccessor.setFlickerModifier(Ingredient.ofItems(Items.GLOWSTONE_DUST, glowItems.GLOWSTONE_DUST));
+
+        if(GlowstoneWire.CONFIG.addConversionRecipes) {
+            // Base JsonObjects
+            JsonObject cIngredientVanilla = new JsonObject();
+            JsonObject CIngredientModded = new JsonObject();
+            JsonArray cIngredientsList = new JsonArray();
+    
+            cIngredientVanilla.addProperty("item", "minecraft:glowstone_dust");
+            CIngredientModded.addProperty("item", "glowstonewire:glowstone_dust");
+
+            // FOR VANILLA TO MODDED
+            VANILLA_TO_MODDED = new JsonObject();
+            // Header, defining what type of crafting recipe it is
+            VANILLA_TO_MODDED.addProperty("type", "minecraft:crafting_shapeless");
+            // Adding the ingredients
+            cIngredientsList.add(cIngredientVanilla);
+            VANILLA_TO_MODDED.add("ingredients", cIngredientsList);
+            // Adding the result
+            VANILLA_TO_MODDED.add("result", CIngredientModded);
+
+            // Clearing out the old array for new
+            cIngredientsList = new JsonArray();
+    
+            // FOR MODDED TO VANILLA
+            MODDED_TO_VANILLA = new JsonObject();
+            // Define recipe type
+            MODDED_TO_VANILLA.addProperty("type", "minecraft:crafting_shapeless");
+            // Add ingredients
+            cIngredientsList.add(CIngredientModded);
+            MODDED_TO_VANILLA.add("ingredients", cIngredientsList);
+            // Add result
+            MODDED_TO_VANILLA.add("result", cIngredientVanilla);
+        }
+    }
+}

src/main/java/me/parsell/glowstonewire/mixin/BrewingRecipeRegistryInvoker.java

@@ -0,0 +1,16 @@
+package me.parsell.glowstonewire.mixin;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Invoker;
+
+import net.minecraft.item.Item;
+import net.minecraft.potion.Potion;
+import net.minecraft.recipe.BrewingRecipeRegistry;
+
+@Mixin(BrewingRecipeRegistry.class)
+public interface BrewingRecipeRegistryInvoker {
+    @Invoker("registerPotionRecipe")
+    public static void registerPotionRecipe(Potion input, Item item, Potion output) {
+        throw new AssertionError();
+     }
+}

src/main/java/me/parsell/glowstonewire/mixin/FireworkStarRecipeAccessor.java

@@ -0,0 +1,20 @@
+package me.parsell.glowstonewire.mixin;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+import net.minecraft.recipe.FireworkStarRecipe;
+import net.minecraft.recipe.Ingredient;
+
+@Mixin(FireworkStarRecipe.class)
+public interface FireworkStarRecipeAccessor {
+    @Accessor("FLICKER_MODIFIER")
+    public static Ingredient getFlickerModifier(){
+        throw new AssertionError();
+    }
+
+    @Accessor("FLICKER_MODIFIER")
+    public static void setFlickerModifier(Ingredient FLICKER_MODIFIER){
+        throw new AssertionError();
+    }
+}

src/main/java/me/parsell/glowstonewire/mixin/LootManagerInjector.java

@@ -0,0 +1,27 @@
+package me.parsell.glowstonewire.mixin;
+
+import java.util.Map;
+
+import com.google.gson.JsonElement;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import me.parsell.glowstonewire.GlowstoneWire;
+import me.parsell.glowstonewire.core.glowLootTables;
+import net.minecraft.loot.LootManager;
+import net.minecraft.resource.ResourceManager;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.profiler.Profiler;
+
+@Mixin(LootManager.class)
+public class LootManagerInjector {
+    @Inject(method = "apply", at = @At("HEAD"))
+    public void interceptApply(Map<Identifier, JsonElement> map, ResourceManager resourceManager, Profiler profiler, CallbackInfo info) {
+        if (GlowstoneWire.CONFIG.replaceGlowstoneDrop) {
+            map.put(new Identifier("minecraft", "blocks/glowstone"), glowLootTables.glowstonelootTable);
+        }
+    }
+}

src/main/java/me/parsell/glowstonewire/mixin/RecipeManagerInjector.java

@@ -0,0 +1,28 @@
+package me.parsell.glowstonewire.mixin;
+
+import java.util.Map;
+
+import com.google.gson.JsonElement;
+
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+import me.parsell.glowstonewire.GlowstoneWire;
+import me.parsell.glowstonewire.core.glowRecipes;
+import net.minecraft.recipe.RecipeManager;
+import net.minecraft.resource.ResourceManager;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.profiler.Profiler;
+
+@Mixin(RecipeManager.class)
+public class RecipeManagerInjector {
+    @Inject(method = "apply", at = @At("HEAD"))
+    public void interceptApply(Map<Identifier, JsonElement> map, ResourceManager resourceManager, Profiler profiler, CallbackInfo info) {
+        if (GlowstoneWire.CONFIG.addConversionRecipes) {
+            map.put(new Identifier(GlowstoneWire.MODID, "glowstone_vanilla_modded"), glowRecipes.VANILLA_TO_MODDED);
+            map.put(new Identifier(GlowstoneWire.MODID, "glowstone_modded_vanilla"), glowRecipes.MODDED_TO_VANILLA);
+        }
+    }
+}

src/main/resources/assets/glowstonewire/blockstates/glowstone_wire.json

@@ -4,10 +4,10 @@
       "when": {
         "OR": [
           {
-            "south": "none",
-            "north": "none",
-            "west": "none",
-            "east": "none"
+            "south": "none|broke",
+            "north": "none|broke",
+            "west": "none|broke",
+            "east": "none|broke"
           },
           {
             "north": "side|up",
@@ -39,9 +39,9 @@
           },
           {
             "south": "side|up",
-            "north": "none",
-            "west": "none",
-            "east": "none"
+            "north": "none|broke",
+            "west": "none|broke",
+            "east": "none|broke"
           }
         ]
       },
@@ -56,10 +56,16 @@
             "south": "side|up"
           },
           {
-            "south": "none",
+            "south": "none|broke",
             "north": "side|up",
-            "west": "none",
-            "east": "none"
+            "west": "none|broke",
+            "east": "none|broke"
+          },
+          {
+            "south": "broke",
+            "north": "side|up",
+            "west": "broke",
+            "east": "broke"
           }
         ]
       },
@@ -74,10 +80,16 @@
             "east": "side|up"
           },
           {
-            "south": "none",
-            "north": "none",
+            "south": "none|broke",
+            "north": "none|broke",
             "west": "side|up",
-            "east": "none"
+            "east": "none|broke"
+          },
+          {
+            "south": "broke",
+            "north": "broke",
+            "west": "side|up",
+            "east": "broke"
           }
         ]
       },
@@ -93,9 +105,15 @@
             "west": "side|up"
           },
           {
-            "south": "none",
-            "north": "none",
-            "west": "none",
+            "south": "none|broke",
+            "north": "none|broke",
+            "west": "none|broke",
+            "east": "side|up"
+          },
+          {
+            "south": "broke",
+            "north": "broke",
+            "west": "broke",
             "east": "side|up"
           }
         ]

src/main/resources/assets/glowstonewire/lang/en_us.json

@@ -0,0 +1,4 @@
+{
+    "itemGroup.glowstonewire.general": "Glowstone Wire",
+    "block.glowstonewire.glowstone_wire": "Glowstone Dust"
+}

src/main/resources/assets/glowstonewire/models/item/glowstone_dust.json

@@ -0,0 +1,6 @@
+{
+  "parent": "item/generated",
+  "textures": {
+    "layer0": "glowstonewire:item/glowstone_dust"
+  }
+}

src/main/resources/data/glowstonewire/loot_tables/blocks/glowstone_wire.json

@@ -0,0 +1,19 @@
+{
+    "type": "minecraft:block",
+    "pools": [
+      {
+        "rolls": 1,
+        "entries": [
+          {
+            "type": "minecraft:item",
+            "name": "glowstonewire:glowstone_dust"
+          }
+        ],
+        "conditions": [
+          {
+            "condition": "minecraft:survives_explosion"
+          }
+        ]
+      }
+    ]
+  }

src/main/resources/data/glowstonewire/recipes/gw_glowstone.json

@@ -0,0 +1,15 @@
+{
+    "type": "minecraft:crafting_shaped",
+    "pattern": [
+      "##",
+      "##"
+    ],
+    "key": {
+      "#": {
+        "item": "glowstonewire:glowstone_dust"
+      }
+    },
+    "result": {
+      "item": "minecraft:glowstone"
+    }
+  }

src/main/resources/data/glowstonewire/recipes/gw_spectral_arrow.json

@@ -0,0 +1,20 @@
+{
+    "type": "minecraft:crafting_shaped",
+    "pattern": [
+      " # ",
+      "#X#",
+      " # "
+    ],
+    "key": {
+      "#": {
+        "item": "glowstonewire:glowstone_dust"
+      },
+      "X": {
+        "item": "minecraft:arrow"
+      }
+    },
+    "result": {
+      "item": "minecraft:spectral_arrow",
+      "count": 2
+    }
+  }

src/main/resources/fabric.mod.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "id": "glowstonewire",
-  "version": "${version}",
+  "version": "1.0.0",
 
   "name": "Glowstone Wire",
   "description": "Adds redstone like dust in the form of glowstone, used to emit a lower light level in a small form factor",
@@ -9,8 +9,8 @@
     "Ganku (Badjman)"
   ],
   "contact": {
-    "homepage": "https://fabricmc.net/",
-    "sources": "https://github.com/FabricMC/fabric-example-mod"
+    "homepage": "",
+    "sources": "https://git.parsell.me/Justi/GlowstoneWire/"
   },
 
   "license": "MIT",
@@ -32,9 +32,9 @@
   "depends": {
     "fabricloader": ">=0.7.4",
     "fabric": "*",
-    "minecraft": "1.16.x"
+    "minecraft": "1.16.x",
+    "cloth-config2": ">=4.11.26"
   },
   "suggests": {
-    "another-mod": "*"
   }
 }

src/main/resources/glowstonewire.mixins.json

@@ -1,12 +1,15 @@
 {
   "required": true,
   "minVersion": "0.8",
-  "package": "me.parsell.glowstonedust.mixin",
+  "package": "me.parsell.glowstonewire.mixin",
   "compatibilityLevel": "JAVA_8",
   "mixins": [
   ],
   "client": [
-    
+    "BrewingRecipeRegistryInvoker",
+    "RecipeManagerInjector",
+    "LootManagerInjector",
+    "FireworkStarRecipeAccessor"
   ],
   "injectors": {
     "defaultRequire": 1