init

src/main/java/magistu/siegemachines/SiegeMachines.java

@@ -0,0 +1,123 @@
+package magistu.siegemachines;
+
+import magistu.siegemachines.block.ModBlocks;
+import magistu.siegemachines.client.ClientProxy;
+import magistu.siegemachines.client.SoundTypes;
+import magistu.siegemachines.config.SpecsConfig;
+import magistu.siegemachines.data.recipes.ModRecipes;
+import magistu.siegemachines.gui.ContainerTypes;
+import magistu.siegemachines.entity.EntityTypes;
+import magistu.siegemachines.item.ModItems;
+import magistu.siegemachines.network.PacketHandler;
+import magistu.siegemachines.proxy.IProxy;
+import magistu.siegemachines.server.ServerProxy;
+import net.minecraft.block.Block;
+import net.minecraft.block.Blocks;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.event.RegistryEvent;
+import net.minecraftforge.eventbus.api.IEventBus;
+import net.minecraftforge.eventbus.api.SubscribeEvent;
+import net.minecraftforge.fml.DistExecutor;
+import net.minecraftforge.fml.InterModComms;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
+import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent;
+import net.minecraftforge.fml.event.lifecycle.InterModEnqueueEvent;
+import net.minecraftforge.fml.event.lifecycle.InterModProcessEvent;
+import net.minecraftforge.fml.event.server.FMLServerStartingEvent;
+import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.util.UUID;
+import java.util.stream.Collectors;
+
+// The value here should match an entry in the META-INF/mods.toml file
+@Mod("siegemachines")
+public class SiegeMachines
+{
+    public static final String ID = "siegemachines";
+
+    public static final IProxy PROXY = DistExecutor.safeRunForDist(() -> ClientProxy::new, () -> ServerProxy::new);
+    public static final int RENDER_UPDATE_RANGE = 128;
+    public static final int RENDER_UPDATE_TIME = 20;
+    public static final int RENDER_UPDATE_RANGE_SQR = RENDER_UPDATE_RANGE * RENDER_UPDATE_RANGE;
+
+    public static final UUID CHAT_UUID = new UUID(100L, 100L);
+
+    // Directly reference a log4j logger.
+    private static final Logger LOGGER = LogManager.getLogger();
+
+
+    public SiegeMachines()
+    {
+        IEventBus eventBus = FMLJavaModLoadingContext.get().getModEventBus();
+
+        FMLJavaModLoadingContext.get().getModEventBus().addListener(this::setup);
+        FMLJavaModLoadingContext.get().getModEventBus().addListener(this::enqueueIMC);
+        FMLJavaModLoadingContext.get().getModEventBus().addListener(this::processIMC);
+        FMLJavaModLoadingContext.get().getModEventBus().addListener(this::doClientStuff);
+
+        EntityTypes.register(eventBus);
+        SoundTypes.register(eventBus);
+        ContainerTypes.register(eventBus);
+        ModBlocks.register(eventBus);
+        ModItems.register(eventBus);
+        ModRecipes.register(eventBus);
+        SpecsConfig.register();
+        
+        PacketHandler.init();
+
+        MinecraftForge.EVENT_BUS.register(this);
+    }
+
+
+    private void setup(final FMLCommonSetupEvent event)
+    {
+        // some preinit code
+        LOGGER.info("HELLO FROM PREINIT");
+        LOGGER.info("DIRT BLOCK >> {}", Blocks.DIRT.getRegistryName());
+    }
+
+    private void doClientStuff(final FMLClientSetupEvent event)
+    {
+        // do something that can only be done on the client
+        LOGGER.info("Got game settings {}", event.getMinecraftSupplier().get().options);
+
+        PROXY.clientSetup(event);
+	}
+
+    private void enqueueIMC(final InterModEnqueueEvent event)
+    {
+        // some example code to dispatch IMC to another mod
+        InterModComms.sendTo("examplemod", "helloworld", () -> { LOGGER.info("Hello world from the MDK"); return "Hello world";});
+    }
+
+    private void processIMC(final InterModProcessEvent event)
+    {
+        // some example code to receive and process InterModComms from other mods
+        LOGGER.info("Got IMC {}", event.getIMCStream().
+                map(m->m.getMessageSupplier().get()).
+                collect(Collectors.toList()));
+    }
+    // You can use SubscribeEvent and let the Event Bus discover methods to call
+    @SubscribeEvent
+    public void onServerStarting(FMLServerStartingEvent event)
+    {
+        // do something when the server starts
+        LOGGER.info("HELLO from server starting");
+    }
+
+    // You can use EventBusSubscriber to automatically subscribe events on the contained class (this is subscribing to the MOD
+    // Event bus for receiving Registry Events)
+    @Mod.EventBusSubscriber(bus=Mod.EventBusSubscriber.Bus.MOD)
+    public static class RegistryEvents
+    {
+        @SubscribeEvent
+        public static void onBlocksRegistry(final RegistryEvent.Register<Block> blockRegistryEvent)
+        {
+            // register a new block here
+            LOGGER.info("HELLO from Register Block");
+        }
+    }
+}

src/main/java/magistu/siegemachines/block/ModBlocks.java

@@ -0,0 +1,39 @@
+package magistu.siegemachines.block;
+
+import magistu.siegemachines.SiegeMachines;
+import magistu.siegemachines.item.ModItems;
+import net.minecraft.block.AbstractBlock;
+import net.minecraft.block.Block;
+import net.minecraft.block.SoundType;
+import net.minecraft.block.material.Material;
+import net.minecraft.item.BlockItem;
+import net.minecraft.item.Item;
+import net.minecraftforge.eventbus.api.IEventBus;
+import net.minecraftforge.fml.RegistryObject;
+import net.minecraftforge.registries.DeferredRegister;
+import net.minecraftforge.registries.ForgeRegistries;
+
+import java.util.function.Supplier;
+
+public class ModBlocks
+{
+    public static final DeferredRegister<Block> BLOCKS = DeferredRegister.create(ForgeRegistries.BLOCKS, SiegeMachines.ID);
+    public static final RegistryObject<SiegeWorkbench> SIEGE_WORKBENCH = registerBlock("siege_workbench", () -> new SiegeWorkbench(AbstractBlock.Properties.of(Material.WOOD).strength(2.5f).sound(SoundType.WOOD)));
+
+    private static <T extends Block>RegistryObject<T> registerBlock(String name, Supplier<T> block)
+    {
+        RegistryObject<T> toReturn = BLOCKS.register(name, block);
+        registerBlockItem(name, toReturn);
+        return toReturn;
+    }
+
+    private static <T extends Block> void registerBlockItem(String name, RegistryObject<T> block)
+    {
+        ModItems.ITEMS.register(name, () -> new BlockItem(block.get(), new Item.Properties().tab(ModItems.GROUP_SM)));
+    }
+
+    public static void register(IEventBus eventBus)
+    {
+        BLOCKS.register(eventBus);
+    }
+}

src/main/java/magistu/siegemachines/block/SiegeWorkbench.java

@@ -0,0 +1,50 @@
+package magistu.siegemachines.block;
+
+import magistu.siegemachines.gui.SiegeWorkbenchContainer;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.CraftingTableBlock;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.entity.player.ServerPlayerEntity;
+import net.minecraft.inventory.container.INamedContainerProvider;
+import net.minecraft.inventory.container.SimpleNamedContainerProvider;
+import net.minecraft.util.ActionResultType;
+import net.minecraft.util.Hand;
+import net.minecraft.util.IWorldPosCallable;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.BlockRayTraceResult;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.TranslationTextComponent;
+import net.minecraft.world.World;
+import net.minecraftforge.fml.network.NetworkHooks;
+import org.jetbrains.annotations.NotNull;
+
+public class SiegeWorkbench extends CraftingTableBlock
+{
+    private static final ITextComponent CONTAINER_TITLE = new TranslationTextComponent("container.crafting");
+
+    public SiegeWorkbench(Properties p_i48422_1_)
+    {
+        super(p_i48422_1_);
+    }
+
+    public @NotNull ActionResultType use(BlockState blockstate, World level, BlockPos blockpos, PlayerEntity player, Hand hand, BlockRayTraceResult result)
+    {
+        if (level.isClientSide)
+        {
+            return ActionResultType.SUCCESS;
+        }
+        else
+        {
+            NetworkHooks.openGui((ServerPlayerEntity) player, this.getMenuProvider(blockstate, level, blockpos));
+            return ActionResultType.CONSUME;
+        }
+    }
+
+    public INamedContainerProvider getMenuProvider(BlockState blockstate, World level, BlockPos blockpos)
+    {
+        return new SimpleNamedContainerProvider((p_220270_2_, p_220270_3_, p_220270_4_) ->
+                new SiegeWorkbenchContainer(p_220270_2_, p_220270_3_, IWorldPosCallable.create(level, blockpos)), CONTAINER_TITLE);
+    }
+
+
+}

src/main/java/magistu/siegemachines/block/StacksCraftingInventory.java

@@ -0,0 +1,12 @@
+package magistu.siegemachines.block;
+
+import net.minecraft.inventory.CraftingInventory;
+import net.minecraft.inventory.container.Container;
+
+public class StacksCraftingInventory extends CraftingInventory
+{
+    public StacksCraftingInventory(Container p_i1807_1_, int p_i1807_2_, int p_i1807_3_)
+    {
+        super(p_i1807_1_, p_i1807_2_, p_i1807_3_);
+    }
+}

src/main/java/magistu/siegemachines/client/ClientListener.java

@@ -0,0 +1,27 @@
+package magistu.siegemachines.client;
+
+import magistu.siegemachines.SiegeMachines;
+import magistu.siegemachines.client.renderer.*;
+import magistu.siegemachines.entity.EntityTypes;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import net.minecraftforge.eventbus.api.SubscribeEvent;
+import net.minecraftforge.fml.client.registry.RenderingRegistry;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
+
+@Mod.EventBusSubscriber(modid = SiegeMachines.ID, bus = Mod.EventBusSubscriber.Bus.MOD)
+public class ClientListener
+{
+	@OnlyIn(Dist.CLIENT)
+	@SubscribeEvent
+	public static void registerRenderers(final FMLClientSetupEvent event)
+	{
+        RenderingRegistry.registerEntityRenderingHandler(EntityTypes.MORTAR.get(), MortarGeoRenderer::new);
+		RenderingRegistry.registerEntityRenderingHandler(EntityTypes.CULVERIN.get(), CulverinGeoRenderer::new);
+		RenderingRegistry.registerEntityRenderingHandler(EntityTypes.TREBUCHET.get(), TrebuchetGeoRenderer::new);
+        RenderingRegistry.registerEntityRenderingHandler(EntityTypes.CATAPULT.get(), CatapultGeoRenderer::new);
+		RenderingRegistry.registerEntityRenderingHandler(EntityTypes.BALLISTA.get(), BallistaGeoRenderer::new);
+		RenderingRegistry.registerEntityRenderingHandler(EntityTypes.BATTERING_RAM.get(), BatteringRamGeoRenderer::new);
+	}
+}

src/main/java/magistu/siegemachines/client/ClientProxy.java

@@ -0,0 +1,37 @@
+package magistu.siegemachines.client;
+
+import magistu.siegemachines.client.renderer.GiantArrowRenderer;
+import magistu.siegemachines.entity.EntityTypes;
+import magistu.siegemachines.gui.ContainerTypes;
+import magistu.siegemachines.gui.MachineInventoryScreen;
+import magistu.siegemachines.gui.SiegeWorkbenchScreen;
+import magistu.siegemachines.proxy.IProxy;
+import net.minecraft.client.gui.ScreenManager;
+import net.minecraft.client.renderer.ItemRenderer;
+import net.minecraft.client.renderer.entity.SpriteRenderer;
+import net.minecraftforge.eventbus.api.IEventBus;
+import net.minecraftforge.fml.client.registry.RenderingRegistry;
+import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
+
+public class ClientProxy implements IProxy
+{
+    public void setup(IEventBus modEventBus, IEventBus forgeEventBus)
+    {
+        modEventBus.addListener(this::clientSetup);
+    }
+
+    public void clientSetup(FMLClientSetupEvent event)
+    {
+        ScreenManager.register(ContainerTypes.MACHINE_CONTAINER.get(), MachineInventoryScreen::new);
+        ScreenManager.register(ContainerTypes.SIEGE_WORKBENCH_CONTAINER.get(), SiegeWorkbenchScreen::new);
+
+        ItemRenderer renderer = event.getMinecraftSupplier().get().getItemRenderer();
+        RenderingRegistry.registerEntityRenderingHandler(EntityTypes.CANNONBALL.get(), (renderManager) -> new SpriteRenderer<>(renderManager, renderer));
+        RenderingRegistry.registerEntityRenderingHandler(EntityTypes.STONE.get(), (renderManager) -> new SpriteRenderer<>(renderManager, renderer));
+        RenderingRegistry.registerEntityRenderingHandler(EntityTypes.GIANT_STONE.get(), (renderManager) -> new SpriteRenderer<>(renderManager, renderer));
+        RenderingRegistry.registerEntityRenderingHandler(EntityTypes.GIANT_ARROW.get(), GiantArrowRenderer::new);
+        KeyBindings.register();
+    }
+
+    public void onPreInit() {}
+}

src/main/java/magistu/siegemachines/client/KeyBindings.java

@@ -0,0 +1,17 @@
+package magistu.siegemachines.client;
+
+import magistu.siegemachines.SiegeMachines;
+import net.minecraft.client.settings.KeyBinding;
+import net.minecraftforge.fml.client.registry.ClientRegistry;
+
+public class KeyBindings
+{
+    public static KeyBinding MACHINE_USE = new KeyBinding(SiegeMachines.ID + ".machine_use", 70, SiegeMachines.ID + ".category");
+    public static KeyBinding MACHINE_INVENTORY = new KeyBinding(SiegeMachines.ID + ".machine_inventory", 73, SiegeMachines.ID + ".category");
+
+    public static void register()
+    {
+        ClientRegistry.registerKeyBinding(MACHINE_USE);
+        ClientRegistry.registerKeyBinding(MACHINE_INVENTORY);
+    }
+}

src/main/java/magistu/siegemachines/client/SoundTypes.java

@@ -0,0 +1,44 @@
+package magistu.siegemachines.client;
+
+import magistu.siegemachines.SiegeMachines;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.SoundEvent;
+import net.minecraftforge.eventbus.api.IEventBus;
+import net.minecraftforge.fml.RegistryObject;
+import net.minecraftforge.registries.DeferredRegister;
+import net.minecraftforge.registries.ForgeRegistries;
+import software.bernie.geckolib3.GeckoLib;
+
+public class SoundTypes
+{
+	public static final DeferredRegister<SoundEvent> SOUNDS = DeferredRegister.create(ForgeRegistries.SOUND_EVENTS,
+			SiegeMachines.ID);
+
+	public static RegistryObject<SoundEvent> TREBUCHET_SHOOTING = SOUNDS.register("trebuchet_shooting",
+			() -> new SoundEvent(new ResourceLocation(SiegeMachines.ID, "trebuchet_shooting")));
+	public static RegistryObject<SoundEvent> TREBUCHET_RELOADING = SOUNDS.register("trebuchet_reloading",
+			() -> new SoundEvent(new ResourceLocation(SiegeMachines.ID, "trebuchet_reloading")));
+	public static RegistryObject<SoundEvent> CATAPULT_SHOOTING = SOUNDS.register("catapult_shooting",
+			() -> new SoundEvent(new ResourceLocation(SiegeMachines.ID, "catapult_shooting")));
+	public static RegistryObject<SoundEvent> CATAPULT_RELOADING = SOUNDS.register("catapult_reloading",
+			() -> new SoundEvent(new ResourceLocation(SiegeMachines.ID, "catapult_reloading")));
+	public static RegistryObject<SoundEvent> BALLISTA_SHOOTING = SOUNDS.register("ballista_shooting",
+			() -> new SoundEvent(new ResourceLocation(SiegeMachines.ID, "ballista_shooting")));
+	public static RegistryObject<SoundEvent> BALLISTA_RELOADING = SOUNDS.register("ballista_reloading",
+			() -> new SoundEvent(new ResourceLocation(SiegeMachines.ID, "ballista_reloading")));
+	public static RegistryObject<SoundEvent> MORTAR_SHOOTING = SOUNDS.register("mortar_shooting",
+			() -> new SoundEvent(new ResourceLocation(SiegeMachines.ID, "mortar_shooting")));
+	public static RegistryObject<SoundEvent> FUSE = SOUNDS.register("fuse",
+			() -> new SoundEvent(new ResourceLocation(SiegeMachines.ID, "fuse")));
+    public static RegistryObject<SoundEvent> CANNON_WHEELS = SOUNDS.register("cannon_wheels",
+			() -> new SoundEvent(new ResourceLocation(SiegeMachines.ID, "cannon_wheels")));
+	public static RegistryObject<SoundEvent> RAM_WHEELS = SOUNDS.register("ram_wheels",
+			() -> new SoundEvent(new ResourceLocation(SiegeMachines.ID, "ram_wheels")));
+	public static RegistryObject<SoundEvent> RAM_HITTING = SOUNDS.register("ram_hitting",
+			() -> new SoundEvent(new ResourceLocation(SiegeMachines.ID, "ram_hitting")));
+
+	public static void register(IEventBus eventBus)
+    {
+        SOUNDS.register(eventBus);
+    }
+}

src/main/java/magistu/siegemachines/client/renderer/BallistaGeoRenderer.java

@@ -0,0 +1,55 @@
+package magistu.siegemachines.client.renderer;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+import com.mojang.blaze3d.vertex.IVertexBuilder;
+import magistu.siegemachines.client.renderer.model.MachineModel;
+import magistu.siegemachines.entity.machine.Ballista;
+import magistu.siegemachines.entity.projectile.ProjectileBuilder;
+import magistu.siegemachines.item.ModItems;
+import net.minecraft.client.renderer.IRenderTypeBuffer;
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.client.renderer.entity.EntityRendererManager;
+import net.minecraft.util.ResourceLocation;
+import software.bernie.geckolib3.geo.render.built.GeoBone;
+import software.bernie.geckolib3.geo.render.built.GeoModel;
+import software.bernie.geckolib3.model.provider.GeoModelProvider;
+
+import java.util.Optional;
+
+public class BallistaGeoRenderer extends MachineGeoRenderer<Ballista>
+{
+	public BallistaGeoRenderer(EntityRendererManager renderManager)
+	{
+		super(renderManager, new MachineModel<>("ballista"));
+	}
+
+	@Override
+	public RenderType getRenderType(Ballista animatable, float partialTicks, MatrixStack stack,
+									IRenderTypeBuffer renderTypeBuffer, IVertexBuilder vertexBuilder, int packedLightIn,
+									ResourceLocation textureLocation)
+	{
+		return RenderType.entityTranslucent(getTextureLocation(animatable));
+	}
+
+	@Override
+	public void renderEarly(Ballista animatable, MatrixStack stackIn, float ticks, IRenderTypeBuffer renderTypeBuffer, IVertexBuilder vertexBuilder, int packedLightIn, int packedOverlayIn, float red, float green, float blue, float partialTicks)
+	{
+		GeoModelProvider<Ballista> modelProvider = this.getGeoModelProvider();
+		GeoModel model = modelProvider.getModel(modelProvider.getModelLocation(animatable));
+
+		Optional<GeoBone> turret = model.getBone("Balliste");
+		turret.ifPresent(bone -> bone.setRotationX(-animatable.getTurretPitch() * (float) Math.PI / 180.0f));
+		turret.ifPresent(bone -> bone.setRotationY(-animatable.getTurretYaw() * (float) Math.PI / 180.0f));
+
+		Optional<GeoBone> projectile = model.getBone("BallistaArrow");
+		projectile.ifPresent(bone -> bone.setRotationX(-animatable.getTurretPitch() * (float) Math.PI / 180.0f));
+		projectile.ifPresent(bone -> bone.setRotationY(-animatable.getTurretYaw() * (float) Math.PI / 180.0f));
+		boolean shouldrender = ((animatable.useticks <= 0 && animatable.shootingticks <= 0) || (animatable.useticks > 0 && animatable.shootingticks > 0)) && animatable.delayticks <= 0;
+		int projectilesize = shouldrender && animatable.hasAmmo() ? 1 : 0;
+		projectile.ifPresent(bone -> bone.setScaleX(projectilesize));
+		projectile.ifPresent(bone -> bone.setScaleY(projectilesize));
+		projectile.ifPresent(bone -> bone.setScaleZ(projectilesize));
+
+		super.renderEarly(animatable, stackIn, ticks, renderTypeBuffer, vertexBuilder, packedLightIn, packedOverlayIn, red, green, blue, partialTicks);
+	}
+}

src/main/java/magistu/siegemachines/client/renderer/BallistaItemGeoRenderer.java

@@ -0,0 +1,11 @@
+package magistu.siegemachines.client.renderer;
+
+import magistu.siegemachines.client.renderer.model.MachineItemModel;
+
+public class BallistaItemGeoRenderer extends MachineItemGeoRenderer
+{
+	public BallistaItemGeoRenderer()
+	{
+		super(new MachineItemModel<>("ballista"));
+	}
+}

src/main/java/magistu/siegemachines/client/renderer/BatteringRamGeoRenderer.java

@@ -0,0 +1,32 @@
+package magistu.siegemachines.client.renderer;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+import com.mojang.blaze3d.vertex.IVertexBuilder;
+import magistu.siegemachines.client.renderer.model.MachineModel;
+import magistu.siegemachines.entity.machine.Ballista;
+import magistu.siegemachines.entity.machine.BatteringRam;
+import net.minecraft.client.renderer.IRenderTypeBuffer;
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.client.renderer.entity.EntityRendererManager;
+import net.minecraft.util.ResourceLocation;
+import software.bernie.geckolib3.geo.render.built.GeoBone;
+import software.bernie.geckolib3.geo.render.built.GeoModel;
+import software.bernie.geckolib3.model.provider.GeoModelProvider;
+
+import java.util.Optional;
+
+public class BatteringRamGeoRenderer extends MachineGeoRenderer<BatteringRam>
+{
+	public BatteringRamGeoRenderer(EntityRendererManager renderManager)
+	{
+		super(renderManager, new MachineModel<>("battering_ram"));
+	}
+
+	@Override
+	public RenderType getRenderType(BatteringRam animatable, float partialTicks, MatrixStack stack,
+									IRenderTypeBuffer renderTypeBuffer, IVertexBuilder vertexBuilder, int packedLightIn,
+									ResourceLocation textureLocation)
+	{
+		return RenderType.entityTranslucent(getTextureLocation(animatable));
+	}
+}

src/main/java/magistu/siegemachines/client/renderer/BatteringRamItemGeoRenderer.java

@@ -0,0 +1,11 @@
+package magistu.siegemachines.client.renderer;
+
+import magistu.siegemachines.client.renderer.model.MachineItemModel;
+
+public class BatteringRamItemGeoRenderer extends MachineItemGeoRenderer
+{
+	public BatteringRamItemGeoRenderer()
+	{
+		super(new MachineItemModel<>("battering_ram"));
+	}
+}

src/main/java/magistu/siegemachines/client/renderer/CatapultGeoRenderer.java

@@ -0,0 +1,26 @@
+package magistu.siegemachines.client.renderer;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+import com.mojang.blaze3d.vertex.IVertexBuilder;
+import magistu.siegemachines.client.renderer.model.MachineModel;
+import magistu.siegemachines.entity.machine.Catapult;
+import net.minecraft.client.renderer.IRenderTypeBuffer;
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.client.renderer.entity.EntityRendererManager;
+import net.minecraft.util.ResourceLocation;
+
+public class CatapultGeoRenderer extends MachineGeoRenderer<Catapult>
+{
+	public CatapultGeoRenderer(EntityRendererManager renderManager)
+	{
+		super(renderManager, new MachineModel<>("catapult"));
+	}
+
+	@Override
+	public RenderType getRenderType(Catapult animatable, float partialTicks, MatrixStack stack,
+			IRenderTypeBuffer renderTypeBuffer, IVertexBuilder vertexBuilder, int packedLightIn,
+			ResourceLocation textureLocation)
+	{
+		return RenderType.entityTranslucent(getTextureLocation(animatable));
+	}
+}

src/main/java/magistu/siegemachines/client/renderer/CatapultItemGeoRenderer.java

@@ -0,0 +1,11 @@
+package magistu.siegemachines.client.renderer;
+
+import magistu.siegemachines.client.renderer.model.MachineItemModel;
+
+public class CatapultItemGeoRenderer extends MachineItemGeoRenderer
+{
+	public CatapultItemGeoRenderer()
+	{
+		super(new MachineItemModel<>("catapult"));
+	}
+}

src/main/java/magistu/siegemachines/client/renderer/CulverinGeoRenderer.java

@@ -0,0 +1,32 @@
+package magistu.siegemachines.client.renderer;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+import com.mojang.blaze3d.vertex.IVertexBuilder;
+import magistu.siegemachines.client.renderer.model.MachineModel;
+import magistu.siegemachines.entity.machine.Culverin;
+import magistu.siegemachines.entity.machine.Mortar;
+import net.minecraft.client.renderer.IRenderTypeBuffer;
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.client.renderer.entity.EntityRendererManager;
+import net.minecraft.util.ResourceLocation;
+import software.bernie.geckolib3.geo.render.built.GeoBone;
+import software.bernie.geckolib3.geo.render.built.GeoModel;
+import software.bernie.geckolib3.model.provider.GeoModelProvider;
+
+import java.util.Optional;
+
+public class CulverinGeoRenderer extends MachineGeoRenderer<Culverin>
+{
+	public CulverinGeoRenderer(EntityRendererManager renderManager)
+	{
+		super(renderManager, new MachineModel<>("culverin"));
+	}
+
+	@Override
+	public RenderType getRenderType(Culverin animatable, float partialTicks, MatrixStack stack,
+			IRenderTypeBuffer renderTypeBuffer, IVertexBuilder vertexBuilder, int packedLightIn,
+			ResourceLocation textureLocation)
+	{
+		return RenderType.entityTranslucent(getTextureLocation(animatable));
+	}
+}

src/main/java/magistu/siegemachines/client/renderer/CulverinItemGeoRenderer.java

@@ -0,0 +1,11 @@
+package magistu.siegemachines.client.renderer;
+
+import magistu.siegemachines.client.renderer.model.MachineItemModel;
+
+public class CulverinItemGeoRenderer extends MachineItemGeoRenderer
+{
+	public CulverinItemGeoRenderer()
+	{
+		super(new MachineItemModel<>("culverin"));
+	}
+}

src/main/java/magistu/siegemachines/client/renderer/GiantArrowRenderer.java

@@ -0,0 +1,54 @@
+package magistu.siegemachines.client.renderer;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+import com.mojang.blaze3d.vertex.IVertexBuilder;
+import magistu.siegemachines.SiegeMachines;
+import magistu.siegemachines.client.renderer.model.GiantArrowModel;
+import magistu.siegemachines.entity.projectile.GiantArrow;
+import net.minecraft.client.renderer.IRenderTypeBuffer;
+import net.minecraft.client.renderer.entity.EntityRenderer;
+import net.minecraft.client.renderer.entity.EntityRendererManager;
+import net.minecraft.client.renderer.texture.OverlayTexture;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.MathHelper;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import org.jetbrains.annotations.NotNull;
+
+@OnlyIn(Dist.CLIENT)
+public class GiantArrowRenderer extends EntityRenderer<GiantArrow>
+{
+    public static final ResourceLocation TEXTURE_LOCATION = new ResourceLocation(SiegeMachines.ID, "textures/entity/giant_arrow.png");
+//    public static final ResourceLocation TEXTURE_LOCATION = new ResourceLocation("textures/entity/projectiles/arrow.png");
+
+    public GiantArrowModel model = new GiantArrowModel();
+
+    public GiantArrowRenderer(EntityRendererManager p_i46547_1_)
+    {
+        super(p_i46547_1_);
+    }
+
+    @Override
+    public @NotNull ResourceLocation getTextureLocation(@NotNull GiantArrow p_110775_1_)
+    {
+        return TEXTURE_LOCATION;
+    }
+
+    public void render(@NotNull GiantArrow giantarrow, float p_225623_2_, float p_225623_3_, @NotNull MatrixStack matrixstack, @NotNull IRenderTypeBuffer buffer, int n)
+    {
+        matrixstack.pushPose();
+        matrixstack.scale(-1.0F, -1.0F, -1.0F);
+        float f = MathHelper.lerp(p_225623_3_, giantarrow.yRotO, giantarrow.yRot);
+        float f1 = -MathHelper.lerp(p_225623_3_, giantarrow.xRotO, giantarrow.xRot);
+        float f2 = (float) giantarrow.shakeTime - p_225623_3_;
+        if (f2 > 0.0F)
+        {
+            f1 -= MathHelper.sin(f2 * 3.0F) * f2;
+        }
+        IVertexBuilder ivertexbuilder = buffer.getBuffer(this.model.renderType(this.getTextureLocation(giantarrow)));
+        this.model.setupAnim(0.0F, f, f1);
+        this.model.renderToBuffer(matrixstack, ivertexbuilder, n, OverlayTexture.NO_OVERLAY, 1.0F, 1.0F, 1.0F, 1.0F);
+        matrixstack.popPose();
+        super.render(giantarrow, p_225623_2_, p_225623_3_, matrixstack, buffer, n);
+    }
+}

src/main/java/magistu/siegemachines/client/renderer/MachineGeoRenderer.java

@@ -0,0 +1,21 @@
+package magistu.siegemachines.client.renderer;
+
+import magistu.siegemachines.entity.machine.Machine;
+import net.minecraft.client.renderer.entity.EntityRendererManager;
+import software.bernie.geckolib3.core.IAnimatable;
+import software.bernie.geckolib3.model.AnimatedGeoModel;
+import software.bernie.geckolib3.renderers.geo.GeoEntityRenderer;
+
+public abstract class MachineGeoRenderer<T extends Machine & IAnimatable> extends GeoEntityRenderer<T>
+{
+    protected MachineGeoRenderer(EntityRendererManager rendermanager, AnimatedGeoModel<T> model)
+    {
+        super(rendermanager, model);
+    }
+
+    @Override
+    protected float getDeathMaxRotation(T entity)
+    {
+		return 0.0F;
+	}
+}

src/main/java/magistu/siegemachines/client/renderer/MachineItemGeoRenderer.java

@@ -0,0 +1,26 @@
+package magistu.siegemachines.client.renderer;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+import com.mojang.blaze3d.vertex.IVertexBuilder;
+import magistu.siegemachines.client.renderer.MachineGeoRenderer;
+import magistu.siegemachines.client.renderer.model.MachineItemModel;
+import magistu.siegemachines.entity.machine.Mortar;
+import magistu.siegemachines.item.MachineItem;
+import net.minecraft.client.renderer.IRenderTypeBuffer;
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.client.renderer.entity.EntityRendererManager;
+import net.minecraft.util.ResourceLocation;
+import software.bernie.geckolib3.geo.render.built.GeoBone;
+import software.bernie.geckolib3.geo.render.built.GeoModel;
+import software.bernie.geckolib3.model.provider.GeoModelProvider;
+import software.bernie.geckolib3.renderers.geo.GeoItemRenderer;
+
+import java.util.Optional;
+
+public class MachineItemGeoRenderer extends GeoItemRenderer<MachineItem>
+{
+	public MachineItemGeoRenderer(MachineItemModel<MachineItem> model)
+	{
+		super(model);
+	}
+}

src/main/java/magistu/siegemachines/client/renderer/MortarGeoRenderer.java

@@ -0,0 +1,44 @@
+package magistu.siegemachines.client.renderer;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+import com.mojang.blaze3d.vertex.IVertexBuilder;
+import magistu.siegemachines.client.renderer.model.MachineModel;
+import magistu.siegemachines.entity.machine.Mortar;
+import net.minecraft.client.renderer.IRenderTypeBuffer;
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.client.renderer.entity.EntityRendererManager;
+import net.minecraft.util.ResourceLocation;
+import software.bernie.geckolib3.geo.render.built.GeoBone;
+import software.bernie.geckolib3.geo.render.built.GeoModel;
+import software.bernie.geckolib3.model.provider.GeoModelProvider;
+
+import java.util.Optional;
+
+public class MortarGeoRenderer extends MachineGeoRenderer<Mortar>
+{
+	public MortarGeoRenderer(EntityRendererManager renderManager)
+	{
+		super(renderManager, new MachineModel<>("mortar"));
+	}
+
+	@Override
+	public RenderType getRenderType(Mortar animatable, float partialTicks, MatrixStack stack,
+			IRenderTypeBuffer renderTypeBuffer, IVertexBuilder vertexBuilder, int packedLightIn,
+			ResourceLocation textureLocation)
+	{
+		return RenderType.entityTranslucent(getTextureLocation(animatable));
+	}
+
+	@Override
+	public void renderEarly(Mortar animatable, MatrixStack stackIn, float ticks, IRenderTypeBuffer renderTypeBuffer, IVertexBuilder vertexBuilder, int packedLightIn, int packedOverlayIn, float red, float green, float blue, float partialTicks)
+	{
+		GeoModelProvider<Mortar> modelProvider = this.getGeoModelProvider();
+		GeoModel model = modelProvider.getModel(modelProvider.getModelLocation(animatable));
+
+		Optional<GeoBone> bone0 = model.getBone("Barrel");
+		bone0.ifPresent(bone -> bone.setRotationX(-animatable.getTurretPitch() * (float) Math.PI / 180.0f));
+		bone0.ifPresent(bone -> bone.setRotationY(-animatable.getTurretYaw() * (float) Math.PI / 180.0f));
+
+		super.renderEarly(animatable, stackIn, ticks, renderTypeBuffer, vertexBuilder, packedLightIn, packedOverlayIn, red, green, blue, partialTicks);
+	}
+}

src/main/java/magistu/siegemachines/client/renderer/MortarItemGeoRenderer.java

@@ -0,0 +1,12 @@
+package magistu.siegemachines.client.renderer;
+
+import magistu.siegemachines.client.renderer.MachineItemGeoRenderer;
+import magistu.siegemachines.client.renderer.model.MachineItemModel;
+
+public class MortarItemGeoRenderer extends MachineItemGeoRenderer
+{
+	public MortarItemGeoRenderer()
+	{
+		super(new MachineItemModel<>("mortar"));
+	}
+}

src/main/java/magistu/siegemachines/client/renderer/TrebuchetGeoRenderer.java

@@ -0,0 +1,47 @@
+package magistu.siegemachines.client.renderer;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+import com.mojang.blaze3d.vertex.IVertexBuilder;
+import magistu.siegemachines.client.renderer.model.MachineModel;
+import magistu.siegemachines.entity.machine.Trebuchet;
+import net.minecraft.client.renderer.IRenderTypeBuffer;
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.client.renderer.entity.EntityRendererManager;
+import net.minecraft.item.Items;
+import net.minecraft.util.ResourceLocation;
+import software.bernie.geckolib3.geo.render.built.GeoBone;
+import software.bernie.geckolib3.geo.render.built.GeoModel;
+import software.bernie.geckolib3.model.provider.GeoModelProvider;
+
+import java.util.Optional;
+
+public class TrebuchetGeoRenderer extends MachineGeoRenderer<Trebuchet>
+{
+	public TrebuchetGeoRenderer(EntityRendererManager renderManager)
+	{
+		super(renderManager, new MachineModel<>("trebuchet"));
+	}
+
+	@Override
+	public RenderType getRenderType(Trebuchet animatable, float partialTicks, MatrixStack stack,
+			IRenderTypeBuffer renderTypeBuffer, IVertexBuilder vertexBuilder, int packedLightIn,
+			ResourceLocation textureLocation)
+	{
+		return RenderType.entityTranslucent(getTextureLocation(animatable));
+	}
+
+	@Override
+	public void renderEarly(Trebuchet animatable, MatrixStack stackIn, float ticks, IRenderTypeBuffer renderTypeBuffer, IVertexBuilder vertexBuilder, int packedLightIn, int packedOverlayIn, float red, float green, float blue, float partialTicks)
+	{
+		GeoModelProvider<Trebuchet> modelProvider = this.getGeoModelProvider();
+		GeoModel model = modelProvider.getModel(modelProvider.getModelLocation(animatable));
+
+		Optional<GeoBone> projectile = model.getBone("Cobblestone");
+		int projectilesize = (animatable.state == Trebuchet.State.IDLE_RELOADED || animatable.shootingticks > 0) && animatable.hasAmmo() ? 1 : 0;
+		projectile.ifPresent(bone -> bone.setScaleX(projectilesize));
+		projectile.ifPresent(bone -> bone.setScaleY(projectilesize));
+		projectile.ifPresent(bone -> bone.setScaleZ(projectilesize));
+
+		super.renderEarly(animatable, stackIn, ticks, renderTypeBuffer, vertexBuilder, packedLightIn, packedOverlayIn, red, green, blue, partialTicks);
+	}
+}

src/main/java/magistu/siegemachines/client/renderer/TrebuchetItemGeoRenderer.java

@@ -0,0 +1,12 @@
+package magistu.siegemachines.client.renderer;
+
+import magistu.siegemachines.client.renderer.MachineItemGeoRenderer;
+import magistu.siegemachines.client.renderer.model.MachineItemModel;
+
+public class TrebuchetItemGeoRenderer extends MachineItemGeoRenderer
+{
+	public TrebuchetItemGeoRenderer()
+	{
+		super(new MachineItemModel<>("trebuchet"));
+	}
+}

src/main/java/magistu/siegemachines/client/renderer/model/GiantArrowModel.java

@@ -0,0 +1,58 @@
+package magistu.siegemachines.client.renderer.model;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+import com.mojang.blaze3d.vertex.IVertexBuilder;
+import net.minecraft.client.renderer.RenderType;
+import net.minecraft.client.renderer.model.Model;
+import net.minecraft.client.renderer.model.ModelRenderer;
+
+public class GiantArrowModel extends Model
+{
+	private final ModelRenderer cube_r0;
+	private final ModelRenderer cube_r1;
+	private final ModelRenderer cube_r2;
+
+	public GiantArrowModel()
+	{
+		super(RenderType::entityCutout);
+		texWidth = 64;
+		texHeight = 64;
+
+		cube_r0 = new ModelRenderer(this);
+		cube_r0.setPos(0.0F, 0.0F, 0.0F);
+		setRotationAngle(cube_r0, 0.0F, 0.0F, 0.0F);
+
+		cube_r1 = new ModelRenderer(this);
+		cube_r1.setPos(0.0F, 0.0F, 3.0F);
+		cube_r0.addChild(cube_r1);
+		setRotationAngle(cube_r1, 0.0F, 0.0F, -0.7854F);
+		cube_r1.texOffs(15, 0).addBox(-2.0F, 0.0F, -10.0F, 4.0F, 0.0F, 4.0F, 0.0F, false);
+		cube_r1.texOffs(-34, 0).addBox(-2.5F, 0.0F, -7.0F, 5.0F, 0.0F, 34.0F, 0.0F, false);
+
+		cube_r2 = new ModelRenderer(this);
+		cube_r2.setPos(0.0F, 0.0F, 3.0F);
+		cube_r0.addChild(cube_r2);
+		setRotationAngle(cube_r2, 0.0F, 0.0F, 0.7854F);
+		cube_r2.texOffs(7, 0).addBox(-2.0F, 0.0F, -10.0F, 4.0F, 0.0F, 4.0F, 0.0F, false);
+		cube_r2.texOffs(-34, 0).addBox(-2.5F, 0.0F, -7.0F, 5.0F, 0.0F, 34.0F, 0.0F, false);
+	}
+
+	public void setupAnim(float p_225603_1_, float p_225603_2_, float p_225603_3_)
+	{
+		this.cube_r0.yRot = p_225603_2_ * ((float)Math.PI / 180F);
+		this.cube_r0.xRot = p_225603_3_ * ((float)Math.PI / 180F);
+	}
+
+	public void setRotationAngle(ModelRenderer modelRenderer, float x, float y, float z)
+	{
+		modelRenderer.xRot = x;
+		modelRenderer.yRot = y;
+		modelRenderer.zRot = z;
+	}
+
+	@Override
+	public void renderToBuffer(MatrixStack p_225598_1_, IVertexBuilder p_225598_2_, int p_225598_3_, int p_225598_4_, float p_225598_5_, float p_225598_6_, float p_225598_7_, float p_225598_8_)
+	{
+		cube_r0.render(p_225598_1_, p_225598_2_, p_225598_3_, p_225598_4_, p_225598_5_, p_225598_6_, p_225598_7_, p_225598_8_);
+	}
+}

src/main/java/magistu/siegemachines/client/renderer/model/MachineItemModel.java

@@ -0,0 +1,42 @@
+package magistu.siegemachines.client.renderer.model;
+
+import magistu.siegemachines.SiegeMachines;
+import magistu.siegemachines.item.MachineItem;
+import net.minecraft.util.ResourceLocation;
+import software.bernie.geckolib3.core.IAnimatable;
+import software.bernie.geckolib3.model.AnimatedGeoModel;
+
+
+public class MachineItemModel<T extends MachineItem & IAnimatable> extends AnimatedGeoModel<T>
+{
+    public final String name;
+	public final ResourceLocation animationlocation;
+	public final ResourceLocation modellocation;
+	public final ResourceLocation texturelocation;
+
+	public MachineItemModel(String name)
+	{
+		this.name = name;
+		this.animationlocation = new ResourceLocation(SiegeMachines.ID, "animations/none.animation.json");
+		this.modellocation = new ResourceLocation(SiegeMachines.ID, "geo/" + this.name + "_item.geo.json");
+		this.texturelocation = new ResourceLocation(SiegeMachines.ID, "textures/entity/" + this.name + ".png");
+	}
+
+    @Override
+	public ResourceLocation getAnimationFileLocation(T entity)
+	{
+		return this.animationlocation;
+	}
+
+	@Override
+	public ResourceLocation getModelLocation(T entity)
+	{
+		return this.modellocation;
+	}
+
+	@Override
+	public ResourceLocation getTextureLocation(T entity)
+	{
+		return this.texturelocation;
+	}
+}

src/main/java/magistu/siegemachines/client/renderer/model/MachineModel.java

@@ -0,0 +1,42 @@
+package magistu.siegemachines.client.renderer.model;
+
+import magistu.siegemachines.SiegeMachines;
+import magistu.siegemachines.entity.machine.Machine;
+import net.minecraft.util.ResourceLocation;
+import software.bernie.geckolib3.core.IAnimatable;
+import software.bernie.geckolib3.model.AnimatedGeoModel;
+
+
+public class MachineModel<T extends Machine & IAnimatable> extends AnimatedGeoModel<T>
+{
+    public final String name;
+	public final ResourceLocation animationlocation;
+	public final ResourceLocation modellocation;
+	public final ResourceLocation texturelocation;
+
+	public MachineModel(String name)
+	{
+		this.name = name;
+		this.animationlocation = new ResourceLocation(SiegeMachines.ID, "animations/" + this.name + ".animation.json");
+		this.modellocation = new ResourceLocation(SiegeMachines.ID, "geo/" + this.name + ".geo.json");
+		this.texturelocation = new ResourceLocation(SiegeMachines.ID, "textures/entity/" + this.name + ".png");
+	}
+
+    @Override
+	public ResourceLocation getAnimationFileLocation(T entity)
+	{
+		return this.animationlocation;
+	}
+
+	@Override
+	public ResourceLocation getModelLocation(T entity)
+	{
+		return this.modellocation;
+	}
+
+	@Override
+	public ResourceLocation getTextureLocation(T entity)
+	{
+		return this.texturelocation;
+	}
+}

src/main/java/magistu/siegemachines/config/MissileSpecs.java

@@ -0,0 +1,21 @@
+package magistu.siegemachines.config;
+
+import net.minecraftforge.common.ForgeConfigSpec;
+
+public class MissileSpecs
+{
+    public final ForgeConfigSpec.ConfigValue<Float> mass;
+    public final ForgeConfigSpec.ConfigValue<Float> explosionpower;
+    public final ForgeConfigSpec.ConfigValue<Boolean> destroysground;
+
+    public MissileSpecs(ForgeConfigSpec.Builder builder, String name, float mass, float explosionpower, boolean destroysground) 
+    {
+        builder.push(name);
+
+        this.mass = builder.define("mass", mass);
+        this.explosionpower = builder.define("explosionRadius", explosionpower);
+        this.destroysground = builder.define("destroysGround", destroysground);
+
+        builder.pop();
+    }
+}

src/main/java/magistu/siegemachines/config/SiegeMachineSpecs.java

@@ -0,0 +1,27 @@
+package magistu.siegemachines.config;
+
+import net.minecraftforge.common.ForgeConfigSpec;
+
+public final class SiegeMachineSpecs
+{
+    private final String name;
+
+    public final ForgeConfigSpec.ConfigValue<Integer> durability;
+    public final ForgeConfigSpec.ConfigValue<Integer> delaytime;
+    public final ForgeConfigSpec.ConfigValue<Float> projectilespeed;
+    public final ForgeConfigSpec.ConfigValue<Float> inaccuracy;
+
+    public SiegeMachineSpecs(ForgeConfigSpec.Builder builder, String name, int durability, int delaytime, float projectilespeed, float inaccuracy)
+    {
+        this.name = name;
+
+        builder.push(name);
+
+        this.durability = builder.define("durability", durability);
+        this.delaytime = builder.define("reloadTime", delaytime);
+        this.projectilespeed = builder.define("projectileSpeed", projectilespeed);
+        this.inaccuracy = builder.define("inaccuracy", inaccuracy);
+
+        builder.pop();
+    }
+}

src/main/java/magistu/siegemachines/config/SpecsConfig.java

@@ -0,0 +1,52 @@
+package magistu.siegemachines.config;
+
+import net.minecraftforge.common.ForgeConfigSpec;
+import net.minecraftforge.fml.ModLoadingContext;
+import net.minecraftforge.fml.config.ModConfig;
+
+public final class SpecsConfig
+{
+    public static final ForgeConfigSpec.Builder BUILDER = new ForgeConfigSpec.Builder();
+    public static final ForgeConfigSpec SPEC;
+
+    public static final SiegeMachineSpecs MORTAR;
+    public static final SiegeMachineSpecs CULVERIN;
+    public static final SiegeMachineSpecs TREBUCHET;
+    public static final SiegeMachineSpecs CATAPULT;
+    public static final SiegeMachineSpecs BALLISTA;
+    public static final SiegeMachineSpecs BATTERING_RAM;
+
+    public static final MissileSpecs CANNONBALL;
+    public static final MissileSpecs STONE;
+    public static final MissileSpecs GIANT_STONE;
+
+    static
+    {
+        BUILDER.push("siege_machines");
+        
+        MORTAR = new SiegeMachineSpecs(BUILDER, "mortar", 80, 200, 2.5f, 0.2f);
+        CULVERIN = new SiegeMachineSpecs(BUILDER, "culverin", 80, 200, 3.0f, 0.2f);
+        TREBUCHET = new SiegeMachineSpecs(BUILDER, "trebuchet", 300, 400, 2.8f, 0.2f);
+        CATAPULT = new SiegeMachineSpecs(BUILDER, "catapult", 100, 200, 2.0f, 0.2f);
+        BALLISTA = new SiegeMachineSpecs(BUILDER, "ballista", 50, 120, 4.5f, 0.04f);
+        BATTERING_RAM = new SiegeMachineSpecs(BUILDER, "battering_ram", 250, 100, 0.0f, 0.5f);
+
+        BUILDER.pop();
+
+        BUILDER.push("missiles");
+
+        CANNONBALL = new MissileSpecs(BUILDER, "cannonball", 15.0f, 3.0f, false);
+        STONE = new MissileSpecs(BUILDER, "stone", 50.0f, 2.0f, false);
+        GIANT_STONE = new MissileSpecs(BUILDER, "giant_stone", 70.0f, 5.0f, false);
+
+        BUILDER.pop();
+        
+        SPEC = BUILDER.build();
+    }
+
+
+    public static void register()
+    {
+        ModLoadingContext.get().registerConfig(ModConfig.Type.COMMON, SPEC, "siege-machines-specs.toml");
+    }
+}

src/main/java/magistu/siegemachines/data/recipes/ISiegeWorkbenchRecipe.java

@@ -0,0 +1,32 @@
+package magistu.siegemachines.data.recipes;
+
+import magistu.siegemachines.SiegeMachines;
+import net.minecraft.inventory.CraftingInventory;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.crafting.IRecipe;
+import net.minecraft.item.crafting.IRecipeType;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.registry.Registry;
+import org.jetbrains.annotations.NotNull;
+
+public interface ISiegeWorkbenchRecipe extends IRecipe<CraftingInventory>
+{
+    ResourceLocation TYPE_ID = new ResourceLocation(SiegeMachines.ID, "siege_workbench");
+
+    @Override
+    default @NotNull IRecipeType<?> getType(){
+        return Registry.RECIPE_TYPE.getOptional(TYPE_ID).get();
+    }
+
+    @Override
+    default boolean canCraftInDimensions(int width, int height)
+    {
+        return true;
+    }
+
+    @Override
+    default boolean isSpecial()
+    {
+        return true;
+    }
+}

src/main/java/magistu/siegemachines/data/recipes/ModRecipes.java

@@ -0,0 +1,25 @@
+package magistu.siegemachines.data.recipes;
+
+import magistu.siegemachines.SiegeMachines;
+import net.minecraft.item.crafting.IRecipeSerializer;
+import net.minecraft.item.crafting.IRecipeType;
+import net.minecraft.util.registry.Registry;
+import net.minecraftforge.eventbus.api.IEventBus;
+import net.minecraftforge.fml.RegistryObject;
+import net.minecraftforge.registries.DeferredRegister;
+import net.minecraftforge.registries.ForgeRegistries;
+
+public class ModRecipes
+{
+    public static final DeferredRegister<IRecipeSerializer<?>> RECIPE_SERIALIZER = DeferredRegister.create(ForgeRegistries.RECIPE_SERIALIZERS, SiegeMachines.ID);
+    public static final RegistryObject<SiegeWorkbenchRecipe.Serializer> SIEGE_WORKBENCH_SERIALIZER = RECIPE_SERIALIZER.register("siege_workbench", SiegeWorkbenchRecipe.Serializer::new);
+
+    public static IRecipeType<SiegeWorkbenchRecipe> SIEGE_WORKBENCH_RECIPE = new SiegeWorkbenchRecipe.SiegeWorkbenchRecipeType();
+
+    public static void register(IEventBus eventBus)
+    {
+        RECIPE_SERIALIZER.register(eventBus);
+
+        Registry.register(Registry.RECIPE_TYPE, SiegeWorkbenchRecipe.TYPE_ID, SIEGE_WORKBENCH_RECIPE);
+    }
+}

src/main/java/magistu/siegemachines/data/recipes/SiegeWorkbenchRecipe.java

@@ -0,0 +1,580 @@
+package magistu.siegemachines.data.recipes;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.google.gson.*;
+import magistu.siegemachines.SiegeMachines;
+import magistu.siegemachines.block.ModBlocks;
+import net.minecraft.inventory.CraftingInventory;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.*;
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.tags.ITag;
+import net.minecraft.tags.TagCollectionManager;
+import net.minecraft.util.JSONUtils;
+import net.minecraft.util.NonNullList;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.registry.Registry;
+import net.minecraft.world.World;
+import org.jetbrains.annotations.NotNull;
+
+import javax.annotation.Nullable;
+import java.util.*;
+import java.util.stream.Stream;
+import java.util.stream.StreamSupport;
+
+
+public class SiegeWorkbenchRecipe implements ISiegeWorkbenchRecipe, net.minecraftforge.common.crafting.IShapedRecipe<CraftingInventory>
+{
+    static int MAX_WIDTH = 3;
+    static int MAX_HEIGHT = 3;
+    /**
+     * Expand the max width and height allowed in the deserializer.
+     * This should be called by modders who add custom crafting tables that are larger than the vanilla 3x3.
+     * @param width your max recipe width
+     * @param height your max recipe height
+     */
+    public static void setCraftingSize(int width, int height)
+    {
+        if (MAX_WIDTH < width) MAX_WIDTH = width;
+        if (MAX_HEIGHT < height) MAX_HEIGHT = height;
+    }
+
+    private final int width;
+    private final int height;
+    private final NonNullList<Ingredient> recipeItems;
+    private final ItemStack result;
+    private final ResourceLocation id;
+    private final String group;
+
+    public SiegeWorkbenchRecipe(ResourceLocation p_i48162_1_, String p_i48162_2_, int p_i48162_3_, int p_i48162_4_, NonNullList<Ingredient> p_i48162_5_, ItemStack p_i48162_6_)
+    {
+        this.id = p_i48162_1_;
+        this.group = p_i48162_2_;
+        this.width = p_i48162_3_;
+        this.height = p_i48162_4_;
+        this.recipeItems = p_i48162_5_;
+        this.result = p_i48162_6_;
+    }
+
+    public static class SiegeWorkbenchRecipeType implements IRecipeType<SiegeWorkbenchRecipe>
+    {
+        @Override
+        public String toString()
+        {
+            return SiegeWorkbenchRecipe.TYPE_ID.toString();
+        }
+    }
+
+    public ResourceLocation getId()
+    {
+        return this.id;
+    }
+
+    public IRecipeSerializer<?> getSerializer()
+    {
+        return ModRecipes.SIEGE_WORKBENCH_SERIALIZER.get();
+    }
+
+    public String getGroup()
+    {
+        return this.group;
+    }
+
+    public ItemStack getResultItem()
+    {
+        return this.result;
+    }
+
+    public @NotNull NonNullList<Ingredient> getIngredients()
+    {
+        return this.recipeItems;
+    }
+
+    public boolean canCraftInDimensions(int p_194133_1_, int p_194133_2_)
+    {
+        return p_194133_1_ >= this.width && p_194133_2_ >= this.height;
+    }
+
+    public boolean testIngredient(Ingredient ingredient, @Nullable ItemStack p_test_1_)
+    {
+        if (p_test_1_ == null)
+        {
+           return false;
+        }
+        else
+        {
+            if (ingredient.getItems().length == 0)
+            {
+               return p_test_1_.isEmpty();
+            }
+            else
+            {
+                for (ItemStack itemstack : ingredient.getItems())
+                {
+                    if (itemstack.getItem() == p_test_1_.getItem() && itemstack.getCount() == p_test_1_.getCount())
+                    {
+                        return true;
+                    }
+                }
+
+                return false;
+            }
+        }
+    }
+
+    public boolean matches(CraftingInventory p_77569_1_, World p_77569_2_)
+    {
+        for (int i = 0; i <= p_77569_1_.getWidth() - this.width; ++i)
+        {
+            for (int j = 0; j <= p_77569_1_.getHeight() - this.height; ++j)
+            {
+                if (this.matches(p_77569_1_, i, j, true))
+                {
+                    return true;
+                }
+
+                if (this.matches(p_77569_1_, i, j, false))
+                {
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+
+    private boolean matches(CraftingInventory p_77573_1_, int p_77573_2_, int p_77573_3_, boolean p_77573_4_)
+    {
+        for (int i = 0; i < p_77573_1_.getWidth(); ++i)
+        {
+            for (int j = 0; j < p_77573_1_.getHeight(); ++j)
+            {
+                int k = i - p_77573_2_;
+                int l = j - p_77573_3_;
+                Ingredient ingredient = Ingredient.EMPTY;
+                if (k >= 0 && l >= 0 && k < this.width && l < this.height)
+                {
+                    if (p_77573_4_)
+                    {
+                        ingredient = this.recipeItems.get(this.width - k - 1 + l * this.width);
+                    }
+                    else
+                    {
+                        ingredient = this.recipeItems.get(k + l * this.width);
+                    }
+                }
+                ItemStack itemstack = p_77573_1_.getItem(i + j * p_77573_1_.getWidth());
+
+                if (!this.testIngredient(ingredient, itemstack))
+                {
+                    return false;
+                }
+            }
+        }
+
+        return true;
+    }
+
+    public ItemStack assemble(CraftingInventory p_77572_1_)
+    {
+        return this.getResultItem().copy();
+    }
+
+    public int getWidth()
+    {
+        return this.width;
+    }
+
+    @Override
+    public int getRecipeWidth()
+    {
+        return getWidth();
+    }
+
+    public int getHeight()
+    {
+        return this.height;
+    }
+
+    @Override
+    public int getRecipeHeight()
+    {
+        return getHeight();
+    }
+
+    @Override
+    public @NotNull ItemStack getToastSymbol()
+    {
+        return new ItemStack(ModBlocks.SIEGE_WORKBENCH.get());
+    }
+
+    private static NonNullList<Ingredient> dissolvePattern(String[] p_192402_0_, Map<String, Ingredient> p_192402_1_, int p_192402_2_, int p_192402_3_)
+    {
+        NonNullList<Ingredient> nonnulllist = NonNullList.withSize(p_192402_2_ * p_192402_3_, Ingredient.EMPTY);
+        Set<String> set = Sets.newHashSet(p_192402_1_.keySet());
+        set.remove(" ");
+
+        for (int i = 0; i < p_192402_0_.length; ++i)
+        {
+            for (int j = 0; j < p_192402_0_[i].length(); ++j)
+            {
+                String s = p_192402_0_[i].substring(j, j + 1);
+                Ingredient ingredient = p_192402_1_.get(s);
+                if (ingredient == null)
+                {
+                    throw new JsonSyntaxException("Pattern references symbol '" + s + "' but it's not defined in the key");
+                }
+
+                set.remove(s);
+                nonnulllist.set(j + p_192402_2_ * i, ingredient);
+            }
+        }
+
+        if (!set.isEmpty())
+        {
+            throw new JsonSyntaxException("Key defines symbols that aren't used in pattern: " + set);
+        }
+        else
+        {
+            return nonnulllist;
+        }
+    }
+
+    @VisibleForTesting
+    static String[] shrink(String... p_194134_0_)
+    {
+        int i = Integer.MAX_VALUE;
+        int j = 0;
+        int k = 0;
+        int l = 0;
+
+        for (int i1 = 0; i1 < p_194134_0_.length; ++i1)
+        {
+            String s = p_194134_0_[i1];
+            i = Math.min(i, firstNonSpace(s));
+            int j1 = lastNonSpace(s);
+            j = Math.max(j, j1);
+            if (j1 < 0)
+            {
+                if (k == i1)
+                {
+                    ++k;
+                }
+
+                ++l;
+            }
+            else
+            {
+                l = 0;
+            }
+        }
+
+        if (p_194134_0_.length == l)
+        {
+            return new String[0];
+        }
+        else
+        {
+            String[] astring = new String[p_194134_0_.length - l - k];
+
+            for (int k1 = 0; k1 < astring.length; ++k1)
+            {
+                astring[k1] = p_194134_0_[k1 + k].substring(i, j + 1);
+            }
+
+            return astring;
+        }
+    }
+
+    private static int firstNonSpace(String p_194135_0_)
+    {
+        int i;
+        for (i = 0; i < p_194135_0_.length() && p_194135_0_.charAt(i) == ' '; ++i)
+        {
+        }
+
+        return i;
+    }
+
+    private static int lastNonSpace(String p_194136_0_)
+    {
+        int i;
+        for (i = p_194136_0_.length() - 1; i >= 0 && p_194136_0_.charAt(i) == ' '; --i)
+        {
+        }
+
+        return i;
+    }
+
+    private static String[] patternFromJson(JsonArray p_192407_0_)
+    {
+        String[] astring = new String[p_192407_0_.size()];
+        if (astring.length > MAX_HEIGHT)
+        {
+            throw new JsonSyntaxException("Invalid pattern: too many rows, " + MAX_HEIGHT + " is maximum");
+        } else if (astring.length == 0)
+        {
+            throw new JsonSyntaxException("Invalid pattern: empty pattern not allowed");
+        }
+        else
+        {
+            for (int i = 0; i < astring.length; ++i)
+            {
+                String s = JSONUtils.convertToString(p_192407_0_.get(i), "pattern[" + i + "]");
+                if (s.length() > MAX_WIDTH)
+                {
+                    throw new JsonSyntaxException("Invalid pattern: too many columns, " + MAX_WIDTH + " is maximum");
+                }
+
+                if (i > 0 && astring[0].length() != s.length())
+                {
+                    throw new JsonSyntaxException("Invalid pattern: each row must be the same width");
+                }
+
+                astring[i] = s;
+            }
+
+            return astring;
+        }
+    }
+
+    public static class TagStackList extends Ingredient.TagList
+    {
+        private final int count;
+
+        public TagStackList(ITag<Item> p_i48193_1_, int count)
+        {
+            super(p_i48193_1_);
+            this.count = count;
+        }
+
+        public Collection<ItemStack> getItems()
+        {
+            Collection<ItemStack> list = super.getItems();
+            list.forEach(ele -> ele.setCount(this.count));
+            return list;
+        }
+
+        public @NotNull JsonObject serialize()
+        {
+           JsonObject jsonobject = super.serialize();
+           return jsonobject;
+        }
+    }
+
+
+    public static Ingredient.IItemList valueFromJson(JsonObject p_199803_0_)
+    {
+        int count = JSONUtils.getAsInt(p_199803_0_, "count", 1);
+        if (p_199803_0_.has("item") && p_199803_0_.has("tag"))
+        {
+            throw new JsonParseException("An ingredient entry is either a tag or an item, not both");
+        }
+        else if (p_199803_0_.has("item"))
+        {
+            ResourceLocation resourcelocation1 = new ResourceLocation(JSONUtils.getAsString(p_199803_0_, "item"));
+            Item item = Registry.ITEM.getOptional(resourcelocation1).orElseThrow(() -> new JsonSyntaxException("Unknown item '" + resourcelocation1 + "'"));
+            return new Ingredient.SingleItemList(new ItemStack(item, count));
+        }
+        else if (p_199803_0_.has("tag"))
+        {
+            ResourceLocation resourcelocation = new ResourceLocation(JSONUtils.getAsString(p_199803_0_, "tag"));
+            ITag<Item> itag = TagCollectionManager.getInstance().getItems().getTag(resourcelocation);
+            if (itag == null)
+            {
+                throw new JsonSyntaxException("Unknown item tag '" + resourcelocation + "'");
+            }
+            else
+            {
+                return new TagStackList(itag, count);
+            }
+        }
+        else
+        {
+            throw new JsonParseException("An ingredient entry needs either a tag or an item");
+        }
+    }
+
+
+//    public static class CompoundIngredientE extends CompoundIngredient
+//    {
+//        protected CompoundIngredientE(List<Ingredient> children)
+//        {
+//            super(children);
+//        }
+//    }
+//
+//
+//    public static Ingredient getIngredient(JsonElement json)
+//    {
+//        if (json == null || json.isJsonNull())
+//            throw new JsonSyntaxException("Json cannot be null");
+//
+//        if (json.isJsonArray())
+//        {
+//            List<Ingredient> ingredients = Lists.newArrayList();
+//            List<Ingredient> vanilla = Lists.newArrayList();
+//            json.getAsJsonArray().forEach((ele) ->
+//            {
+//                Ingredient ing = getIngredient(ele);
+//
+//                if (ing.getClass() == Ingredient.class) //Vanilla, Due to how we read it splits each itemstack, so we pull out to re-merge later
+//                    vanilla.add(ing);
+//                else
+//                    ingredients.add(ing);
+//            });
+//
+//            if (!vanilla.isEmpty())
+//                ingredients.add(Ingredient.merge(vanilla));
+//
+//            if (ingredients.size() == 0)
+//                throw new JsonSyntaxException("Item array cannot be empty, at least one item must be defined");
+//
+//            if (ingredients.size() == 1)
+//                return ingredients.get(0);
+//
+//            return new CompoundIngredientE(ingredients);
+//        }
+//
+//        if (!json.isJsonObject())
+//            throw new JsonSyntaxException("Expcted ingredient to be a object or array of objects");
+//
+//        JsonObject obj = (JsonObject)json;
+//
+//        String type = JSONUtils.getAsString(obj, "type", "minecraft:item");
+//        if (type.isEmpty())
+//            throw new JsonSyntaxException("Ingredient type can not be an empty string");
+//
+//        IIngredientSerializer<?> serializer = ingredients.get(new ResourceLocation(type));
+//        if (serializer == null)
+//            throw new JsonSyntaxException("Unknown ingredient type: " + type);
+//
+//        return serializer.parse(obj);
+//    }
+
+
+    public static Ingredient ingredientFromJson(@Nullable JsonElement p_199802_0_)
+    {
+        if (p_199802_0_ != null && !p_199802_0_.isJsonNull())
+        {
+//            Ingredient ret = CraftingHelper.getIngredient(p_199802_0_);
+//            if (ret != null) return ret;
+
+            if (p_199802_0_.isJsonObject())
+            {
+                return Ingredient.fromValues(Stream.of(valueFromJson(p_199802_0_.getAsJsonObject())));
+            }
+            else if (p_199802_0_.isJsonArray())
+            {
+                JsonArray jsonarray = p_199802_0_.getAsJsonArray();
+                if (jsonarray.size() == 0)
+                {
+                    throw new JsonSyntaxException("Item array cannot be empty, at least one item must be defined");
+                }
+                else
+                {
+                    return Ingredient.fromValues(StreamSupport.stream(jsonarray.spliterator(), false).map((p_209355_0_) -> valueFromJson(JSONUtils.convertToJsonObject(p_209355_0_, "item"))));
+                }
+            }
+            else
+            {
+               throw new JsonSyntaxException("Expected item to be object or array of objects");
+            }
+        }
+        else
+        {
+            throw new JsonSyntaxException("Item cannot be null");
+        }
+    }
+
+
+    private static Map<String, Ingredient> keyFromJson(JsonObject p_192408_0_)
+    {
+        Map<String, Ingredient> map = Maps.newHashMap();
+
+        for (Map.Entry<String, JsonElement> entry : p_192408_0_.entrySet())
+        {
+            if (entry.getKey().length() != 1)
+            {
+                throw new JsonSyntaxException("Invalid key entry: '" + entry.getKey() + "' is an invalid symbol (must be 1 character only).");
+            }
+
+            if (" ".equals(entry.getKey()))
+            {
+                throw new JsonSyntaxException("Invalid key entry: ' ' is a reserved symbol.");
+            }
+
+            Ingredient ingredient = ingredientFromJson(entry.getValue());
+
+            map.put(entry.getKey(), ingredient);
+        }
+
+        map.put(" ", Ingredient.EMPTY);
+        return map;
+    }
+
+    public static ItemStack itemFromJson(JsonObject p_199798_0_)
+    {
+        String s = JSONUtils.getAsString(p_199798_0_, "item");
+        Item item = Registry.ITEM.getOptional(new ResourceLocation(s)).orElseThrow(() -> new JsonSyntaxException("Unknown item '" + s + "'"));
+        if (p_199798_0_.has("data"))
+        {
+            throw new JsonParseException("Disallowed data tag found");
+        }
+        else
+        {
+            int i = JSONUtils.getAsInt(p_199798_0_, "count", 1);
+            return net.minecraftforge.common.crafting.CraftingHelper.getItemStack(p_199798_0_, true);
+        }
+    }
+
+    public static class Serializer extends net.minecraftforge.registries.ForgeRegistryEntry<IRecipeSerializer<?>>  implements IRecipeSerializer<SiegeWorkbenchRecipe>
+    {
+        private static final ResourceLocation NAME = new ResourceLocation(SiegeMachines.ID, "siege_workbench");
+
+        public SiegeWorkbenchRecipe fromJson(ResourceLocation p_199425_1_, JsonObject p_199425_2_)
+        {
+            String s = JSONUtils.getAsString(p_199425_2_, "group", "");
+            Map<String, Ingredient> map = SiegeWorkbenchRecipe.keyFromJson(JSONUtils.getAsJsonObject(p_199425_2_, "key"));
+            String[] astring = SiegeWorkbenchRecipe.shrink(SiegeWorkbenchRecipe.patternFromJson(JSONUtils.getAsJsonArray(p_199425_2_, "pattern")));
+            int i = astring[0].length();
+            int j = astring.length;
+            NonNullList<Ingredient> nonnulllist = SiegeWorkbenchRecipe.dissolvePattern(astring, map, i, j);
+            ItemStack itemstack = SiegeWorkbenchRecipe.itemFromJson(JSONUtils.getAsJsonObject(p_199425_2_, "result"));
+            return new SiegeWorkbenchRecipe(p_199425_1_, s, i, j, nonnulllist, itemstack);
+        }
+
+        public SiegeWorkbenchRecipe fromNetwork(ResourceLocation p_199426_1_, PacketBuffer p_199426_2_)
+        {
+            int i = p_199426_2_.readVarInt();
+            int j = p_199426_2_.readVarInt();
+            String s = p_199426_2_.readUtf(32767);
+            NonNullList<Ingredient> nonnulllist = NonNullList.withSize(i * j, Ingredient.EMPTY);
+
+            for (int k = 0; k < nonnulllist.size(); ++k)
+            {
+                nonnulllist.set(k, Ingredient.fromNetwork(p_199426_2_));
+            }
+
+            ItemStack itemstack = p_199426_2_.readItem();
+            return new SiegeWorkbenchRecipe(p_199426_1_, s, i, j, nonnulllist, itemstack);
+        }
+
+        public void toNetwork(PacketBuffer p_199427_1_, SiegeWorkbenchRecipe p_199427_2_)
+        {
+            p_199427_1_.writeVarInt(p_199427_2_.width);
+            p_199427_1_.writeVarInt(p_199427_2_.height);
+            p_199427_1_.writeUtf(p_199427_2_.group);
+
+            for (Ingredient ingredient : p_199427_2_.recipeItems)
+            {
+                ingredient.toNetwork(p_199427_1_);
+            }
+
+            p_199427_1_.writeItem(p_199427_2_.result);
+        }
+    }
+}

src/main/java/magistu/siegemachines/entity/Breakdown.java

@@ -0,0 +1,326 @@
+package magistu.siegemachines.entity;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import com.google.common.collect.Sets;
+import com.mojang.datafixers.util.Pair;
+import it.unimi.dsi.fastutil.objects.ObjectArrayList;
+import net.minecraft.block.AbstractFireBlock;
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.Blocks;
+import net.minecraft.enchantment.ProtectionEnchantment;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.entity.item.ItemEntity;
+import net.minecraft.entity.item.TNTEntity;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.entity.projectile.ProjectileEntity;
+import net.minecraft.fluid.FluidState;
+import net.minecraft.item.ItemStack;
+import net.minecraft.loot.LootContext;
+import net.minecraft.loot.LootParameters;
+import net.minecraft.particles.ParticleTypes;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.math.*;
+import net.minecraft.util.math.vector.Vector3d;
+import net.minecraft.world.EntityExplosionContext;
+import net.minecraft.world.Explosion;
+import net.minecraft.world.ExplosionContext;
+import net.minecraft.world.World;
+import net.minecraft.world.server.ServerWorld;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.*;
+
+public class Breakdown
+{
+   private static final ExplosionContext EXPLOSION_DAMAGE_CALCULATOR = new ExplosionContext();
+   private final boolean fire;
+   private final Explosion.Mode blockInteraction;
+   private final Random random = new Random();
+   private final World level;
+   private final double x;
+   private final double y;
+   private final double z;
+   @Nullable
+   private final Entity source;
+   private final float radius;
+   private final DamageSource damageSource;
+   private final ExplosionContext damageCalculator;
+   private final List<BlockPos> toBlow = Lists.newArrayList();
+   private final Map<PlayerEntity, Vector3d> hitPlayers = Maps.newHashMap();
+   private final Vector3d position;
+   private final Explosion explosion;
+   private final Entity machine;
+   private final float power;
+
+   public Breakdown(World p_i50007_1_, @Nullable Entity machine, @Nullable Entity p_i50007_2_, double p_i50007_3_, double p_i50007_5_, double p_i50007_7_, float p_i50007_9_, boolean p_i50007_10_, float power, Explosion.Mode p_i50007_11_) {
+      this(p_i50007_1_, p_i50007_2_, machine, (DamageSource)null, (ExplosionContext)null, p_i50007_3_, p_i50007_5_, p_i50007_7_, p_i50007_9_, p_i50007_10_, power, p_i50007_11_);
+   }
+
+   public Breakdown(World p_i231610_1_, @Nullable Entity machine, @Nullable Entity p_i231610_2_, @Nullable DamageSource p_i231610_3_, @Nullable ExplosionContext p_i231610_4_, double p_i231610_5_, double p_i231610_7_, double p_i231610_9_, float p_i231610_11_, boolean p_i231610_12_, float power, Explosion.Mode p_i231610_13_) {
+      this.explosion = new Explosion(p_i231610_1_, p_i231610_2_, p_i231610_3_, p_i231610_4_, p_i231610_5_, p_i231610_7_, p_i231610_9_, p_i231610_11_, p_i231610_12_, p_i231610_13_);
+      this.level = p_i231610_1_;
+      this.machine = machine;
+      this.source = p_i231610_2_;
+      this.radius = p_i231610_11_;
+      this.x = p_i231610_5_;
+      this.y = p_i231610_7_;
+      this.z = p_i231610_9_;
+      this.fire = p_i231610_12_;
+      this.power = power;
+      this.blockInteraction = p_i231610_13_;
+      this.damageSource = p_i231610_3_ == null && p_i231610_2_ instanceof LivingEntity ? DamageSource.explosion((LivingEntity) p_i231610_2_) : p_i231610_3_;
+      this.damageCalculator = p_i231610_4_ == null ? this.makeDamageCalculator(p_i231610_2_) : p_i231610_4_;
+      this.position = new Vector3d(this.x, this.y, this.z);
+   }
+
+   private ExplosionContext makeDamageCalculator(@Nullable Entity p_234894_1_) {
+      return (ExplosionContext)(p_234894_1_ == null ? EXPLOSION_DAMAGE_CALCULATOR : new EntityExplosionContext(p_234894_1_));
+   }
+
+   public static float getSeenPercent(Vector3d p_222259_0_, Entity p_222259_1_) {
+      AxisAlignedBB axisalignedbb = p_222259_1_.getBoundingBox();
+      double d0 = 1.0D / ((axisalignedbb.maxX - axisalignedbb.minX) * 2.0D + 1.0D);
+      double d1 = 1.0D / ((axisalignedbb.maxY - axisalignedbb.minY) * 2.0D + 1.0D);
+      double d2 = 1.0D / ((axisalignedbb.maxZ - axisalignedbb.minZ) * 2.0D + 1.0D);
+      double d3 = (1.0D - Math.floor(1.0D / d0) * d0) / 2.0D;
+      double d4 = (1.0D - Math.floor(1.0D / d2) * d2) / 2.0D;
+      if (!(d0 < 0.0D) && !(d1 < 0.0D) && !(d2 < 0.0D)) {
+         int i = 0;
+         int j = 0;
+
+         for(float f = 0.0F; f <= 1.0F; f = (float)((double)f + d0)) {
+            for(float f1 = 0.0F; f1 <= 1.0F; f1 = (float)((double)f1 + d1)) {
+               for(float f2 = 0.0F; f2 <= 1.0F; f2 = (float)((double)f2 + d2)) {
+                  double d5 = MathHelper.lerp((double)f, axisalignedbb.minX, axisalignedbb.maxX);
+                  double d6 = MathHelper.lerp((double)f1, axisalignedbb.minY, axisalignedbb.maxY);
+                  double d7 = MathHelper.lerp((double)f2, axisalignedbb.minZ, axisalignedbb.maxZ);
+                  Vector3d vector3d = new Vector3d(d5 + d3, d6, d7 + d4);
+                  if (p_222259_1_.level.clip(new RayTraceContext(vector3d, p_222259_0_, RayTraceContext.BlockMode.COLLIDER, RayTraceContext.FluidMode.NONE, p_222259_1_)).getType() == RayTraceResult.Type.MISS) {
+                     ++i;
+                  }
+
+                  ++j;
+               }
+            }
+         }
+
+         return (float)i / (float)j;
+      } else {
+         return 0.0F;
+      }
+   }
+
+   public void explode()
+   {
+      Set<BlockPos> set = Sets.newHashSet();
+      int i = 16;
+
+      for(int j = 0; j < 16; ++j) {
+         for(int k = 0; k < 16; ++k) {
+            for(int l = 0; l < 16; ++l) {
+               if (j == 0 || j == 15 || k == 0 || k == 15 || l == 0 || l == 15) {
+                  double d0 = (double)((float)j / 15.0F * 2.0F - 1.0F);
+                  double d1 = (double)((float)k / 15.0F * 2.0F - 1.0F);
+                  double d2 = (double)((float)l / 15.0F * 2.0F - 1.0F);
+                  double d3 = Math.sqrt(d0 * d0 + d1 * d1 + d2 * d2);
+                  d0 = d0 / d3;
+                  d1 = d1 / d3;
+                  d2 = d2 / d3;
+                  float f = this.power * this.radius * (0.7F + this.level.random.nextFloat() * 0.6F);
+                  double d4 = this.x;
+                  double d6 = this.y;
+                  double d8 = this.z;
+
+                  for(float f1 = 0.3F; f > 0.0F; f -= this.power * 0.5F) {
+                     BlockPos blockpos = new BlockPos(d4, d6, d8);
+                     BlockState blockstate = this.level.getBlockState(blockpos);
+                     FluidState fluidstate = this.level.getFluidState(blockpos);
+                     Optional<Float> optional = this.damageCalculator.getBlockExplosionResistance(this.explosion, this.level, blockpos, blockstate, fluidstate);
+                     if (optional.isPresent()) {
+                        f -= (optional.get() + 0.3F) * 0.3F;
+                     }
+
+                     if (f > 0.0F && this.damageCalculator.shouldBlockExplode(this.explosion, this.level, blockpos, blockstate, f)) {
+                        set.add(blockpos);
+                     }
+
+                     d4 += d0 * (double)0.3F;
+                     d6 += d1 * (double)0.3F;
+                     d8 += d2 * (double)0.3F;
+                  }
+               }
+            }
+         }
+      }
+
+      this.toBlow.addAll(set);
+      float f2 = 1.5f * this.radius;
+      int k1 = MathHelper.floor(this.x - (double)f2 - 1.0D);
+      int l1 = MathHelper.floor(this.x + (double)f2 + 1.0D);
+      int i2 = MathHelper.floor(this.y - (double)f2 - 1.0D);
+      int i1 = MathHelper.floor(this.y + (double)f2 + 1.0D);
+      int j2 = MathHelper.floor(this.z - (double)f2 - 1.0D);
+      int j1 = MathHelper.floor(this.z + (double)f2 + 1.0D);
+      List<Entity> list = this.level.getEntities(this.source, new AxisAlignedBB((double)k1, (double)i2, (double)j2, (double)l1, (double)i1, (double)j1));
+      Vector3d vector3d = new Vector3d(this.x, this.y, this.z);
+
+      for(int k2 = 0; k2 < list.size(); ++k2) {
+         Entity entity = list.get(k2);
+         if (!entity.ignoreExplosion() && !entity.equals(this.machine) && !entity.equals(this.source)) {
+            double d12 = (MathHelper.sqrt(entity.distanceToSqr(vector3d)) / f2);
+            if (d12 <= 1.0D) {
+               double d5 = entity.getX() - this.x;
+               double d7 = (entity instanceof TNTEntity ? entity.getY() : entity.getEyeY()) - this.y;
+               double d9 = entity.getZ() - this.z;
+               double d13 = (double)MathHelper.sqrt(d5 * d5 + d7 * d7 + d9 * d9);
+               if (d13 != 0.0D) {
+                  d5 = d5 / d13;
+                  d7 = d7 / d13;
+                  d9 = d9 / d13;
+                  double d14 = (double)getSeenPercent(vector3d, entity);
+                  double d10 = (1.0D - d12) * d14;
+                  if (!(entity instanceof ItemEntity)) {
+                     entity.hurt(this.getDamageSource(), (float) ((int) ((d10 * d10 + d10) / 2.0D * 7.0D * (double) f2 + 1.0D)));
+                  }
+                  double d11 = d10;
+                  if (entity instanceof LivingEntity) {
+                     d11 = ProtectionEnchantment.getExplosionKnockbackAfterDampener((LivingEntity)entity, d10);
+                  }
+
+                  entity.setDeltaMovement(entity.getDeltaMovement().add(d5 * d11, d7 * d11, d9 * d11));
+                  if (entity instanceof PlayerEntity) {
+                     PlayerEntity playerentity = (PlayerEntity)entity;
+                     if (!playerentity.isSpectator() && (!playerentity.isCreative() || !playerentity.abilities.flying)) {
+                        this.hitPlayers.put(playerentity, new Vector3d(d5 * d10, d7 * d10, d9 * d10));
+                     }
+                  }
+               }
+            }
+         }
+      }
+
+   }
+
+   public void finalizeExplosion(boolean p_77279_1_) {
+      if (this.level.isClientSide) {
+         //this.level.playLocalSound(this.x, this.y, this.z, SoundEvents.GENERIC_EXPLODE, SoundCategory.BLOCKS, 4.0F, (1.0F + (this.level.random.nextFloat() - this.level.random.nextFloat()) * 0.2F) * 0.7F, false);
+      }
+
+      boolean flag = this.blockInteraction != Explosion.Mode.NONE;
+      if (p_77279_1_) {
+         if (!(this.radius < 2.0F) && flag) {
+            this.level.addParticle(ParticleTypes.EXPLOSION_EMITTER, this.x, this.y, this.z, 1.0D, 0.0D, 0.0D);
+         } else {
+            this.level.addParticle(ParticleTypes.EXPLOSION, this.x, this.y, this.z, 1.0D, 0.0D, 0.0D);
+         }
+      }
+
+      if (flag) {
+         ObjectArrayList<Pair<ItemStack, BlockPos>> objectarraylist = new ObjectArrayList<>();
+         Collections.shuffle(this.toBlow, this.level.random);
+
+         for(BlockPos blockpos : this.toBlow) {
+            BlockState blockstate = this.level.getBlockState(blockpos);
+            Block block = blockstate.getBlock();
+            if (!blockstate.isAir(this.level, blockpos)) {
+               BlockPos blockpos1 = blockpos.immutable();
+               this.level.getProfiler().push("explosion_blocks");
+               if (this.level instanceof ServerWorld) {
+                  TileEntity tileentity = blockstate.hasTileEntity() ? this.level.getBlockEntity(blockpos) : null;
+                  LootContext.Builder lootcontext$builder = (new LootContext.Builder((ServerWorld)this.level)).withRandom(this.level.random).withParameter(LootParameters.ORIGIN, Vector3d.atCenterOf(blockpos)).withParameter(LootParameters.TOOL, ItemStack.EMPTY).withOptionalParameter(LootParameters.BLOCK_ENTITY, tileentity).withOptionalParameter(LootParameters.THIS_ENTITY, this.source);
+                  if (this.blockInteraction == Explosion.Mode.DESTROY) {
+                     lootcontext$builder.withParameter(LootParameters.EXPLOSION_RADIUS, this.radius);
+                  }
+
+                  blockstate.getDrops(lootcontext$builder).forEach((p_229977_2_) -> {
+                     addBlockDrops(objectarraylist, p_229977_2_, blockpos1);
+                  });
+               }
+
+               this.level.setBlock(blockpos, Blocks.AIR.defaultBlockState(), 3);
+               this.level.getProfiler().pop();
+            }
+         }
+
+         for(Pair<ItemStack, BlockPos> pair : objectarraylist) {
+            Block.popResource(this.level, pair.getSecond(), pair.getFirst());
+         }
+      }
+
+      if (this.fire) {
+         for(BlockPos blockpos2 : this.toBlow) {
+            if (this.random.nextInt(3) == 0 && this.level.getBlockState(blockpos2).isAir() && this.level.getBlockState(blockpos2.below()).isSolidRender(this.level, blockpos2.below())) {
+               this.level.setBlockAndUpdate(blockpos2, AbstractFireBlock.getState(this.level, blockpos2));
+            }
+         }
+      }
+
+   }
+
+   private static void addBlockDrops(ObjectArrayList<Pair<ItemStack, BlockPos>> p_229976_0_, ItemStack p_229976_1_, BlockPos p_229976_2_) {
+      int i = p_229976_0_.size();
+
+      for(int j = 0; j < i; ++j) {
+         Pair<ItemStack, BlockPos> pair = p_229976_0_.get(j);
+         ItemStack itemstack = pair.getFirst();
+         if (ItemEntity.areMergable(itemstack, p_229976_1_)) {
+            ItemStack itemstack1 = ItemEntity.merge(itemstack, p_229976_1_, 16);
+            p_229976_0_.set(j, Pair.of(itemstack1, pair.getSecond()));
+            if (p_229976_1_.isEmpty()) {
+               return;
+            }
+         }
+      }
+
+      p_229976_0_.add(Pair.of(p_229976_1_, p_229976_2_));
+   }
+
+   public DamageSource getDamageSource() {
+      return this.damageSource;
+   }
+
+   public Map<PlayerEntity, Vector3d> getHitPlayers() {
+      return this.hitPlayers;
+   }
+
+   @Nullable
+   public LivingEntity getSourceMob() {
+      if (this.source == null) {
+         return null;
+      } else if (this.source instanceof TNTEntity) {
+         return ((TNTEntity)this.source).getOwner();
+      } else if (this.source instanceof LivingEntity) {
+         return (LivingEntity)this.source;
+      } else {
+         if (this.source instanceof ProjectileEntity) {
+            Entity entity = ((ProjectileEntity)this.source).getOwner();
+            if (entity instanceof LivingEntity) {
+               return (LivingEntity)entity;
+            }
+         }
+
+         return null;
+      }
+   }
+
+   public void clearToBlow() {
+      this.toBlow.clear();
+   }
+
+   public List<BlockPos> getToBlow() {
+      return this.toBlow;
+   }
+
+   public Vector3d getPosition() {
+      return this.position;
+   }
+
+   @Nullable
+   public Entity getExploder() {
+      return this.source;
+   }
+}

src/main/java/magistu/siegemachines/entity/EntityTypes.java

@@ -0,0 +1,54 @@
+package magistu.siegemachines.entity;
+
+import magistu.siegemachines.SiegeMachines;
+import magistu.siegemachines.entity.machine.*;
+import magistu.siegemachines.entity.projectile.Cannonball;
+import magistu.siegemachines.entity.projectile.GiantArrow;
+import magistu.siegemachines.entity.projectile.GiantStone;
+import magistu.siegemachines.entity.projectile.Stone;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityClassification;
+import net.minecraft.entity.EntityType;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.eventbus.api.IEventBus;
+import net.minecraftforge.fml.RegistryObject;
+import net.minecraftforge.registries.DeferredRegister;
+import net.minecraftforge.registries.ForgeRegistries;
+
+public class EntityTypes
+{
+    public static final DeferredRegister<EntityType<?>> DEFERRED_REGISTER = DeferredRegister.create(ForgeRegistries.ENTITIES, SiegeMachines.ID);
+
+    public static final RegistryObject<EntityType<Cannonball>> CANNONBALL = addRegistry("cannonball", Cannonball::new, 0.5f, 0.5f, 8);
+    public static final RegistryObject<EntityType<Stone>> STONE = addRegistry("stone", Stone::new, 0.6f, 0.6f, 8);
+    public static final RegistryObject<EntityType<GiantStone>> GIANT_STONE = addRegistry("giant_stone", GiantStone::new, 1.1f, 1.1f, 8);
+    public static final RegistryObject<EntityType<GiantArrow>> GIANT_ARROW = addRegistry("giant_arrow", GiantArrow::new, 0.5f, 0.5f, 8, 20);
+
+    public static final RegistryObject<EntityType<Mortar>> MORTAR = addRegistry("mortar", Mortar::new, 2.0f, 1.0f, 8);
+    public static final RegistryObject<EntityType<Culverin>> CULVERIN = addRegistry("culverin", Culverin::new, 2.0f, 1.0f, 8);
+    public static final RegistryObject<EntityType<Trebuchet>> TREBUCHET = addRegistry("trebuchet", Trebuchet::new, 5.0f, 9.0f, 8);
+    public static final RegistryObject<EntityType<Catapult>> CATAPULT = addRegistry("catapult", Catapult::new, 3.0f, 3.0f, 8);
+    public static final RegistryObject<EntityType<Ballista>> BALLISTA = addRegistry("ballista", Ballista::new, 1.5f, 1.5f, 8);
+    public static final RegistryObject<EntityType<BatteringRam>> BATTERING_RAM = addRegistry("battering_ram", BatteringRam::new, 4.0f, 3.0f);
+
+
+    public static <T extends Entity> RegistryObject<EntityType<T>> addRegistry(String name, EntityType.IFactory<T> constructor, float sizex, float sizey)
+    {
+        return DEFERRED_REGISTER.register(name, () -> EntityType.Builder.of(constructor, EntityClassification.MISC).sized(sizex, sizey).build(new ResourceLocation(SiegeMachines.ID, name).toString()));
+    }
+
+    public static <T extends Entity> RegistryObject<EntityType<T>> addRegistry(String name, EntityType.IFactory<T> constructor, float sizex, float sizey, int trackingrange)
+    {
+        return DEFERRED_REGISTER.register(name, () -> EntityType.Builder.of(constructor, EntityClassification.MISC).clientTrackingRange(trackingrange).sized(sizex, sizey).build(new ResourceLocation(SiegeMachines.ID, name).toString()));
+    }
+
+    public static <T extends Entity> RegistryObject<EntityType<T>> addRegistry(String name, EntityType.IFactory<T> constructor, float sizex, float sizey, int trackingrange, int updateinterval)
+    {
+        return DEFERRED_REGISTER.register(name, () -> EntityType.Builder.of(constructor, EntityClassification.MISC).clientTrackingRange(trackingrange).updateInterval(updateinterval).sized(sizex, sizey).build(new ResourceLocation(SiegeMachines.ID, name).toString()));
+    }
+
+    public static void register(IEventBus eventBus)
+    {
+        DEFERRED_REGISTER.register(eventBus);
+    }
+}

src/main/java/magistu/siegemachines/entity/IReloading.java

@@ -0,0 +1,11 @@
+package magistu.siegemachines.entity;
+
+import magistu.siegemachines.gui.Crosshair;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+public interface IReloading
+{
+    @OnlyIn(Dist.CLIENT)
+    Crosshair createCrosshair();
+}

src/main/java/magistu/siegemachines/entity/machine/Ballista.java

@@ -0,0 +1,190 @@
+package magistu.siegemachines.entity.machine;
+
+import magistu.siegemachines.SiegeMachines;
+import magistu.siegemachines.client.SoundTypes;
+import magistu.siegemachines.gui.Crosshair;
+import magistu.siegemachines.gui.ReloadingCrosshair;
+import magistu.siegemachines.item.ModItems;
+import net.minecraft.entity.*;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.CompoundNBT;
+import net.minecraft.util.ActionResultType;
+import net.minecraft.util.DamageSource;
+import net.minecraft.util.Hand;
+import net.minecraft.util.SoundCategory;
+import net.minecraft.util.math.vector.Vector3d;
+import net.minecraft.world.World;
+import net.minecraft.world.server.ServerWorld;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import software.bernie.geckolib3.core.IAnimatable;
+import software.bernie.geckolib3.core.PlayState;
+import software.bernie.geckolib3.core.builder.AnimationBuilder;
+import software.bernie.geckolib3.core.controller.AnimationController;
+import software.bernie.geckolib3.core.event.predicate.AnimationEvent;
+import software.bernie.geckolib3.core.manager.AnimationData;
+import software.bernie.geckolib3.core.manager.AnimationFactory;
+
+public class Ballista extends ShootingMachine implements IAnimatable
+{
+    private final AnimationFactory factory = new AnimationFactory(this);
+
+    static AnimationBuilder SHOOTING_ANIM = new AnimationBuilder().addAnimation("Shooting", true);
+    static AnimationBuilder RELOADING_ANIM = new AnimationBuilder().addAnimation("Reloading", true);
+
+    public enum State
+    {
+        SHOOTING,
+        RELOADING
+    }
+    public State state = State.RELOADING;
+
+    public Ballista(EntityType<? extends MobEntity> entitytype, World level)
+    {
+        super(entitytype, level, MachineType.BALLISTA);
+    }
+
+    private <E extends IAnimatable> PlayState predicate(AnimationEvent<E> event)
+    {
+        switch (state)
+        {
+            case SHOOTING:
+                event.getController().setAnimation(SHOOTING_ANIM);
+                return PlayState.CONTINUE;
+            case RELOADING:
+                event.getController().setAnimation(RELOADING_ANIM);
+                return PlayState.CONTINUE;
+        }
+        return PlayState.CONTINUE;
+	}
+
+    @Override
+	public void registerControllers(AnimationData data)
+    {
+        AnimationController<?> controller = new AnimationController<>(this, "controller", 1, (t) ->
+        {
+            if (this.state.equals(State.RELOADING))
+            {
+                return (double) (this.type.specs.delaytime.get() - this.delayticks) / this.type.specs.delaytime.get();
+            }
+            return t;
+        }, this::predicate);
+		data.addAnimationController(controller);
+	}
+
+    @Override
+    public AnimationFactory getFactory()
+    {
+        return this.factory;
+    }
+
+    @Override
+    protected ActionResultType mobInteract(PlayerEntity player, Hand hand)
+    {
+        if (super.mobInteract(player, hand) == ActionResultType.SUCCESS)
+        {
+            return ActionResultType.SUCCESS;
+        }
+        if (!this.level.isClientSide() && !this.isVehicle())
+        {
+			player.startRiding(this);
+			return ActionResultType.SUCCESS;
+		}
+
+		return ActionResultType.PASS;
+    }
+
+    public void startShooting(PlayerEntity player)
+    {
+        if (this.delayticks <= 0 && this.useticks <= 0 && this.shootingticks <= 0)
+        {
+            this.state = State.SHOOTING;
+            this.useticks = this.type.usetime;
+            this.shootingticks = this.type.userealisetime;
+
+            Vector3d pos = this.position();
+            this.level.playLocalSound(pos.x, pos.y, pos.z, SoundTypes.BALLISTA_SHOOTING.get(), SoundCategory.BLOCKS, 1.4f, 1.0f, false);
+        }
+    }
+
+    @Override
+    public void shoot()
+    {
+        if (!level.isClientSide())
+        {
+            super.shoot();
+        }
+    }
+
+    @Override
+	public void travel(Vector3d pos)
+    {
+		if (this.isAlive())
+        {
+            if (this.isVehicle())
+            {
+			    LivingEntity livingentity = (LivingEntity) this.getControllingPassenger();
+
+                this.setTurretRotationsDest(livingentity.xRot, livingentity.yRot - this.getYaw());
+                this.updateTurretRotations();
+			}
+            super.travel(pos);
+		}
+
+	}
+
+    @Override
+    public void tick()
+    {
+        if (this.useticks != 0 && --this.useticks <= 0)
+        {
+            this.state = State.RELOADING;
+            this.useticks = 0;
+            this.delayticks = this.type.specs.delaytime.get();
+        }
+
+        if (this.shootingticks != 0 && --this.shootingticks <= 0)
+        {
+            this.useRealise();
+            this.shootingticks = 0;
+        }
+
+        if (!level.isClientSide() && (this.isOnGround() || this.isInWater()))
+        {
+            this.setDeltaMovement(this.getDeltaMovement().multiply(0.0, 1.0, 0.0));
+        }
+
+        if (this.delayticks > 0 && this.isVehicle())
+        {
+            if (this.delayticks % 21 == 0)
+            {
+                Vector3d pos = this.position();
+                this.level.playLocalSound(pos.x, pos.y, pos.z, SoundTypes.BALLISTA_RELOADING.get(), SoundCategory.BLOCKS, 1.0f, 1.0f, false);
+            }
+            --this.delayticks;
+        }
+
+        if (this.renderupdateticks-- <= 0)
+        {
+            this.updateMachineRender();
+            this.renderupdateticks = SiegeMachines.RENDER_UPDATE_TIME;
+        }
+
+        super.tick();
+    }
+
+    @Override
+    @OnlyIn(Dist.CLIENT)
+    public Crosshair createCrosshair()
+    {
+        return new ReloadingCrosshair();
+    }
+
+    @Override
+    public Item getMachineItem()
+    {
+        return ModItems.BALLISTA.get();
+    }
+}

src/main/java/magistu/siegemachines/entity/machine/BatteringRam.java

@@ -0,0 +1,254 @@
+package magistu.siegemachines.entity.machine;
+
+import magistu.siegemachines.SiegeMachines;
+import magistu.siegemachines.client.SoundTypes;
+import magistu.siegemachines.entity.Breakdown;
+import magistu.siegemachines.item.ModItems;
+import magistu.siegemachines.network.PacketHandler;
+import magistu.siegemachines.network.PacketMachineUse;
+import magistu.siegemachines.network.PacketMachineUseRealise;
+import net.minecraft.entity.EntityType;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.entity.MobEntity;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.item.Item;
+import net.minecraft.util.ActionResultType;
+import net.minecraft.util.Hand;
+import net.minecraft.util.SoundCategory;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.vector.Vector3d;
+import net.minecraft.world.Explosion;
+import net.minecraft.world.World;
+import software.bernie.geckolib3.core.IAnimatable;
+import software.bernie.geckolib3.core.PlayState;
+import software.bernie.geckolib3.core.builder.AnimationBuilder;
+import software.bernie.geckolib3.core.controller.AnimationController;
+import software.bernie.geckolib3.core.event.predicate.AnimationEvent;
+import software.bernie.geckolib3.core.manager.AnimationData;
+import software.bernie.geckolib3.core.manager.AnimationFactory;
+
+
+public class BatteringRam extends Machine implements IAnimatable
+{
+    private final AnimationFactory factory = new AnimationFactory(this);
+
+    static AnimationBuilder MOVING_ANIM = new AnimationBuilder().addAnimation("Moving", true);
+    static AnimationBuilder HITTING_ANIM = new AnimationBuilder().addAnimation("Hitting", true);
+    static AnimationBuilder RELOADING_ANIM = new AnimationBuilder().addAnimation("Reloading", true);
+
+    public int hittingticks = 0;
+    private int wheelssoundticks = 10;
+
+    public enum State
+    {
+        HITTING,
+        RELOADING
+    }
+    public State state = State.RELOADING;
+
+    private double wheelspitch = 0.0;
+    private double wheelsspeed = 0.0;
+
+    public BatteringRam(EntityType<? extends MobEntity> entitytype, World level)
+    {
+        super(entitytype, level, MachineType.BATTERING_RAM);
+    }
+
+    private <E extends IAnimatable> PlayState wheels_predicate(AnimationEvent<E> event)
+    {
+        event.getController().setAnimation(MOVING_ANIM);
+
+        return PlayState.CONTINUE;
+	}
+
+    private <E extends IAnimatable> PlayState reloading_predicate(AnimationEvent<E> event)
+    {
+        switch (state)
+        {
+            case HITTING:
+                event.getController().setAnimation(HITTING_ANIM);
+                return PlayState.CONTINUE;
+            case RELOADING:
+                event.getController().setAnimation(RELOADING_ANIM);
+                return PlayState.CONTINUE;
+        }
+        return PlayState.CONTINUE;
+	}
+
+    @Override
+	public void registerControllers(AnimationData data)
+    {
+        AnimationController<?> wheels_controller = new AnimationController<>(this, "wheels_controller", 1, (t) -> {
+            double d = this.getWheelsSpeed();
+            this.wheelsspeed = d > 0 ? Math.min(d, 1.0) : Math.max(d, -1.0);
+            return wheelspitch += 0.015 * this.wheelsspeed;
+        }, this::wheels_predicate);
+		data.addAnimationController(wheels_controller);
+
+        AnimationController<?> reloading_controller = new AnimationController<>(this, "controller", 1, (t) ->
+        {
+            if (this.state.equals(State.RELOADING))
+            {
+                return (double) (this.type.specs.delaytime.get() - this.delayticks) / this.type.specs.delaytime.get();
+            }
+            return t;
+        }, this::reloading_predicate);
+		data.addAnimationController(reloading_controller);
+	}
+
+    @Override
+    public AnimationFactory getFactory()
+    {
+        return this.factory;
+    }
+
+    @Override
+    protected ActionResultType mobInteract(PlayerEntity player, Hand hand)
+    {
+        if (!this.level.isClientSide() && !this.isVehicle())
+        {
+			player.startRiding(this);
+			return ActionResultType.SUCCESS;
+		}
+
+		return ActionResultType.PASS;
+    }
+
+    @Override
+	public void travel(Vector3d pos)
+    {
+		if (this.isAlive())
+        {
+            if (this.isVehicle())
+            {
+			    LivingEntity livingentity = (LivingEntity) this.getControllingPassenger();
+
+                this.setYawDest(livingentity.yRot);
+
+                this.updateYaw();
+
+				float f1 = livingentity.zza;
+				if (f1 <= 0.0f)
+                {
+					f1 *= 0.25f;
+				}
+				this.setSpeed(0.04f);
+
+                pos = new Vector3d(0.0f, pos.y, f1);
+			}
+            super.travel(pos);
+		}
+	}
+
+    @Override
+    public void tick()
+    {
+        if (this.useticks != 0 && --this.useticks <= 0)
+        {
+            this.state = State.RELOADING;
+            this.useticks = 0;
+            this.delayticks = this.type.specs.delaytime.get();
+        }
+
+        if (this.hittingticks != 0 && --this.hittingticks <= 0)
+        {
+            this.useRealise();
+            this.hittingticks = 0;
+        }
+
+        if (!level.isClientSide() && (this.isOnGround() || this.isInWater()))
+        {
+            this.setDeltaMovement(this.getDeltaMovement().multiply(0.0, 1.0, 0.0));
+        }
+
+        if (this.delayticks > 0 && this.isVehicle())
+        {
+            --this.delayticks;
+        }
+
+        if (this.renderupdateticks-- <= 0)
+        {
+            this.updateMachineRender();
+            this.renderupdateticks = SiegeMachines.RENDER_UPDATE_TIME;
+        }
+
+//        if (this.getWheelsSpeed() > 0.0081 && this.wheelssoundticks-- <= 0)
+//        {
+//            this.level.playLocalSound(this.getX(), this.getY(), this.getZ(), SoundTypes.RAM_WHEELS.get(), SoundCategory.NEUTRAL, 0.6f, 1.0f, true);
+//            this.wheelssoundticks = 20;
+//        }
+
+        super.tick();
+    }
+
+    @Override
+    public void use(PlayerEntity player)
+    {
+        if (!this.level.isClientSide())
+        {
+            PacketHandler.sendPacketToAllInArea(new PacketMachineUse(this.getId()), this.blockPosition(), SiegeMachines.RENDER_UPDATE_RANGE_SQR);
+        }
+
+        if (this.delayticks <= 0 && this.useticks <= 0 && this.hittingticks <= 0)
+        {
+            this.state = State.HITTING;
+            this.useticks = this.type.usetime;
+            this.hittingticks = this.type.userealisetime;
+
+            Vector3d pos = this.position();
+            this.level.playLocalSound(pos.x, pos.y, pos.z, SoundTypes.RAM_HITTING.get(), SoundCategory.BLOCKS, 0.5f, 0.9f, false);
+        }
+    }
+
+    public void ramHit(BlockPos blockpos)
+    {
+        if (!this.level.isClientSide())
+        {
+            Breakdown breakdown = new Breakdown(this.level, this, this.getControllingPassenger(), blockpos.getX(), blockpos.getY(), blockpos.getZ(), 2, false, 3.0f, Explosion.Mode.BREAK);
+            breakdown.explode();
+            breakdown.finalizeExplosion(true);
+        }
+    }
+
+    @Override
+    public void useRealise()
+    {
+        if (!this.level.isClientSide())
+        {
+            PacketHandler.sendPacketToAllInArea(new PacketMachineUseRealise(this.getId()), this.blockPosition(), SiegeMachines.RENDER_UPDATE_RANGE_SQR);
+
+            BlockPos blockpos = new BlockPos(this.getHitPos());
+            this.ramHit(blockpos);
+        }
+    }
+
+    public double getWheelsSpeed()
+    {
+        if (this.isOnGround())
+        {
+            return this.getViewVector(5.0f).multiply(1, 0, 1).dot(this.getDeltaMovement());
+        }
+
+        return 0.0;
+    }
+
+    @Override
+    public void push(double p_70024_1_, double p_70024_3_, double p_70024_5_) {
+//      this.setDeltaMovement(this.getDeltaMovement().add(p_70024_1_, p_70024_3_, p_70024_5_));
+//      this.hasImpulse = true;
+    }
+
+    @Override
+    public Item getMachineItem()
+    {
+        return ModItems.BATTERING_RAM.get();
+    }
+
+    protected Vector3d getHitPos()
+    {
+        double pitch = this.getTurretPitch() * Math.PI / 180.0;
+        double yaw = (this.getViewYRot(0.5f) + this.getTurretYaw()) * Math.PI / 180.0;
+
+        return this.position().add(applyRotations(this.type.turretpivot, 0.0, yaw).add(applyRotations(this.type.turretvector, pitch, yaw)));
+    }
+}

src/main/java/magistu/siegemachines/entity/machine/Catapult.java

@@ -0,0 +1,207 @@
+package magistu.siegemachines.entity.machine;
+
+import magistu.siegemachines.SiegeMachines;
+import magistu.siegemachines.client.SoundTypes;
+import magistu.siegemachines.gui.Crosshair;
+import magistu.siegemachines.gui.ReloadingCrosshair;
+import magistu.siegemachines.item.ModItems;
+import net.minecraft.entity.EntityType;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.entity.MobEntity;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ActionResultType;
+import net.minecraft.util.Hand;
+import net.minecraft.util.SoundCategory;
+import net.minecraft.util.math.vector.Vector3d;
+import net.minecraft.world.World;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import software.bernie.geckolib3.core.IAnimatable;
+import software.bernie.geckolib3.core.PlayState;
+import software.bernie.geckolib3.core.builder.AnimationBuilder;
+import software.bernie.geckolib3.core.controller.AnimationController;
+import software.bernie.geckolib3.core.event.predicate.AnimationEvent;
+import software.bernie.geckolib3.core.manager.AnimationData;
+import software.bernie.geckolib3.core.manager.AnimationFactory;
+
+public class Catapult extends ShootingMachine implements IAnimatable
+{
+    private final AnimationFactory factory = new AnimationFactory(this);
+
+    static AnimationBuilder SHOOTING_ANIM = new AnimationBuilder().addAnimation("Shooting", true);
+    static AnimationBuilder RELOADING_ANIM = new AnimationBuilder().addAnimation("Reloading", true);
+    static AnimationBuilder IDLE_RELOADED_ANIM = new AnimationBuilder().addAnimation("IdleReloaded", true);
+    static AnimationBuilder IDLE_NOT_RELOADED_ANIM = new AnimationBuilder().addAnimation("IdleNotReloaded", true);
+
+    public enum State
+    {
+        SHOOTING,
+        RELOADING,
+        IDLE_RELOADED,
+        IDLE_NOT_RELOADED
+    }
+    public State state = State.RELOADING;
+
+    public Catapult(EntityType<? extends MobEntity> entitytype, World level)
+    {
+        super(entitytype, level, MachineType.CATAPULT);
+    }
+
+    private <E extends IAnimatable> PlayState predicate(AnimationEvent<E> event)
+    {
+        switch (state)
+        {
+            case SHOOTING:
+                event.getController().setAnimation(SHOOTING_ANIM);
+                return PlayState.CONTINUE;
+            case IDLE_RELOADED:
+                event.getController().setAnimation(IDLE_RELOADED_ANIM);
+                return PlayState.CONTINUE;
+            case RELOADING:
+                event.getController().setAnimation(RELOADING_ANIM);
+                return PlayState.CONTINUE;
+            case IDLE_NOT_RELOADED:
+                event.getController().setAnimation(IDLE_NOT_RELOADED_ANIM);
+                return PlayState.CONTINUE;
+        }
+
+        return PlayState.CONTINUE;
+	}
+
+    @Override
+	public void registerControllers(AnimationData data)
+    {
+        AnimationController<?> controller = new AnimationController<>(this, "controller", 1, (t) ->
+        {
+            if (this.state.equals(State.RELOADING))
+            {
+                return (double) (this.type.specs.delaytime.get() - this.delayticks) / this.type.specs.delaytime.get();
+            }
+            return t;
+        }, this::predicate);
+		data.addAnimationController(controller);
+	}
+
+    @Override
+    public AnimationFactory getFactory()
+    {
+        return this.factory;
+    }
+
+    @Override
+    protected ActionResultType mobInteract(PlayerEntity player, Hand hand)
+    {
+        ItemStack stack = player.getItemInHand(hand);
+
+        if (super.mobInteract(player, hand) == ActionResultType.SUCCESS)
+        {
+            return ActionResultType.SUCCESS;
+        }
+        if (!this.level.isClientSide() && !this.isVehicle())
+        {
+			player.startRiding(this);
+			return ActionResultType.SUCCESS;
+		}
+
+		return ActionResultType.PASS;
+    }
+
+    public void startShooting(PlayerEntity player)
+    {
+        if (this.delayticks <= 0 && this.useticks <= 0 && this.shootingticks <= 0)
+        {
+            this.state = State.SHOOTING;
+            this.useticks = this.type.usetime;
+            this.shootingticks = this.type.userealisetime;
+
+            Vector3d pos = this.position();
+            this.level.playLocalSound(pos.x, pos.y, pos.z, SoundTypes.CATAPULT_SHOOTING.get(), SoundCategory.BLOCKS, 1.5f, 1.0f, false);
+        }
+    }
+
+    @Override
+    public void shoot()
+    {
+        if (!level.isClientSide())
+        {
+            super.shoot();
+        }
+    }
+
+    @Override
+	public void travel(Vector3d pos)
+    {
+		if (this.isAlive())
+        {
+            if (this.isVehicle() && this.useticks <= 0 && this.delayticks <= 0)
+            {
+			    LivingEntity livingentity = (LivingEntity) this.getControllingPassenger();
+
+                this.setTurretRotations(livingentity.xRot, this.getTurretYaw());
+                this.updateTurretRotations();
+
+                this.setYawDest(livingentity.yRot);
+                this.updateYaw();
+			}
+            super.travel(pos);
+		}
+	}
+
+    @Override
+    public void tick()
+    {
+        if (this.useticks != 0 && --this.useticks <= 0)
+        {
+            this.state = State.RELOADING;
+            this.useticks = 0;
+            this.delayticks = this.type.specs.delaytime.get();
+        }
+
+        if (this.shootingticks != 0 && --this.shootingticks <= 0)
+        {
+            this.useRealise();
+            this.shootingticks = 0;
+        }
+
+        if (!level.isClientSide() && (this.isOnGround() || this.isInWater()))
+        {
+            this.setDeltaMovement(this.getDeltaMovement().multiply(0.0, 1.0, 0.0));
+        }
+
+        if (this.delayticks > 0 && this.isVehicle())
+        {
+            if (this.delayticks % 20 == 0)
+            {
+                Vector3d pos = this.position();
+                this.level.playLocalSound(pos.x, pos.y, pos.z, SoundTypes.CATAPULT_RELOADING.get(), SoundCategory.BLOCKS, 1.0f, 1.0f, false);
+            }
+            if (--this.delayticks <= 0)
+            {
+                this.state = State.IDLE_RELOADED;
+            }
+        }
+
+        if (this.renderupdateticks-- <= 0)
+        {
+            this.updateMachineRender();
+            this.renderupdateticks = SiegeMachines.RENDER_UPDATE_TIME;
+        }
+
+        super.tick();
+    }
+
+    @Override
+    @OnlyIn(Dist.CLIENT)
+    public Crosshair createCrosshair()
+    {
+        return new ReloadingCrosshair();
+    }
+
+    @Override
+    public Item getMachineItem()
+    {
+        return ModItems.CATAPULT.get();
+    }
+}

src/main/java/magistu/siegemachines/entity/machine/Culverin.java

@@ -0,0 +1,260 @@
+package magistu.siegemachines.entity.machine;
+
+import magistu.siegemachines.SiegeMachines;
+import magistu.siegemachines.client.SoundTypes;
+import magistu.siegemachines.entity.IReloading;
+import magistu.siegemachines.gui.Crosshair;
+import magistu.siegemachines.gui.ReloadingCrosshair;
+import magistu.siegemachines.item.ModItems;
+import net.minecraft.entity.EntityType;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.entity.MobEntity;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.Items;
+import net.minecraft.particles.ParticleTypes;
+import net.minecraft.util.ActionResultType;
+import net.minecraft.util.Hand;
+import net.minecraft.util.SoundCategory;
+import net.minecraft.util.math.vector.Vector3d;
+import net.minecraft.world.World;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import software.bernie.geckolib3.core.IAnimatable;
+import software.bernie.geckolib3.core.PlayState;
+import software.bernie.geckolib3.core.builder.AnimationBuilder;
+import software.bernie.geckolib3.core.controller.AnimationController;
+import software.bernie.geckolib3.core.event.SoundKeyframeEvent;
+import software.bernie.geckolib3.core.event.predicate.AnimationEvent;
+import software.bernie.geckolib3.core.manager.AnimationData;
+import software.bernie.geckolib3.core.manager.AnimationFactory;
+
+public class Culverin extends ShootingMachine implements IAnimatable, IReloading
+{
+    private final AnimationFactory factory = new AnimationFactory(this);
+
+    static AnimationBuilder MOVING_ANIM = new AnimationBuilder().addAnimation("Moving", true);
+//    static AnimationBuilder TILTING_ANIM = new AnimationBuilder().addAnimation("Tilting", true);
+
+    private double wheelspitch = 0.0;
+    private double wheelsspeed = 0.0;
+
+    public Culverin(EntityType<? extends MobEntity> entitytype, World level)
+    {
+        super(entitytype, level, MachineType.CULVERIN);
+    }
+
+    private <E extends IAnimatable> PlayState wheels_predicate(AnimationEvent<E> event)
+    {
+        event.getController().setAnimation(MOVING_ANIM);
+
+        return PlayState.CONTINUE;
+	}
+
+    @Override
+	public void registerControllers(AnimationData data)
+    {
+        AnimationController<?> wheels_controller = new AnimationController<>(this, "wheels_controller", 1, (t) -> {
+            double d = this.getWheelsSpeed();
+            this.wheelsspeed = d > 0 ? Math.min(d, 1.0) : Math.max(d, -1.0);
+            return wheelspitch += 0.015 * this.wheelsspeed;
+        }, this::wheels_predicate);
+        wheels_controller.registerSoundListener(this::soundListener);
+		data.addAnimationController(wheels_controller);
+	}
+
+    private <ENTITY extends IAnimatable> void soundListener(SoundKeyframeEvent<ENTITY> event)
+    {
+        //ClientPlayerEntity player = Minecraft.getInstance().player;
+        if (/*player != null && */this.getWheelsSpeed() > 0.0081)
+        {
+            Vector3d pos = this.position();
+            this.level.playLocalSound(pos.x, pos.y, pos.z, SoundTypes.CANNON_WHEELS.get(), SoundCategory.BLOCKS, 0.5f/*this.getVolumeFromDist(0.5f, 16.0f, this.distanceTo(player))*/, 1.0f, false);
+        }
+	}
+
+    @Override
+    public AnimationFactory getFactory()
+    {
+        return this.factory;
+    }
+
+    @Override
+    protected ActionResultType mobInteract(PlayerEntity player, Hand hand)
+    {
+        ItemStack stack = player.getItemInHand(hand);
+
+        if (stack.getItem().equals(Items.FLINT_AND_STEEL))
+        {
+            if (this.useticks < 0)
+            {
+                stack.hurtAndBreak(1, player, (p_213833_1_) ->
+                {
+                    p_213833_1_.broadcastBreakEvent(hand);
+                    net.minecraftforge.event.ForgeEventFactory.onPlayerDestroyItem(player, this.useItem, hand);
+                });
+                this.startShooting(player);
+            }
+            return ActionResultType.SUCCESS;
+        }
+        if (stack.getItem().equals(Items.GUNPOWDER))
+        {
+            if (!this.inventory.containsItem(Items.GUNPOWDER))
+            {
+                if (!player.isCreative())
+                {
+                    stack.shrink(1);
+                }
+                this.inventory.putItem(Items.GUNPOWDER);
+            }
+            return ActionResultType.SUCCESS;
+        }
+        if (super.mobInteract(player, hand) == ActionResultType.SUCCESS)
+        {
+            return ActionResultType.SUCCESS;
+        }
+        if (!this.level.isClientSide() && !this.isVehicle())
+        {
+			player.startRiding(this);
+			return ActionResultType.SUCCESS;
+		}
+
+		return ActionResultType.PASS;
+    }
+
+    @Override
+	public void travel(Vector3d pos)
+    {
+		if (this.isAlive())
+        {
+            if (this.isVehicle())
+            {
+			    LivingEntity livingentity = (LivingEntity) this.getControllingPassenger();
+
+                this.setTurretRotationsDest(livingentity.xRot, livingentity.yRot - this.getYaw());
+                this.setYawDest(livingentity.yRot);
+
+                this.updateYaw();
+                this.updateTurretRotations();
+
+				float f0 = livingentity.xxa * 0.2f;
+				float f1 = livingentity.zza;
+				if (f1 <= 0.0f)
+                {
+					f1 *= 0.5f;
+				}
+				this.setSpeed(0.04f);
+
+                pos = new Vector3d(f0, pos.y, f1);
+			}
+            super.travel(pos);
+		}
+	}
+
+    @Override
+    public void tick()
+    {
+        if (this.useticks != 0 && --this.useticks <= 0)
+        {
+            if (this.inventory.containsItem(Items.GUNPOWDER))
+            {
+                this.useRealise();
+            }
+            this.useticks = 0;
+        }
+        if (!level.isClientSide() && (this.isOnGround() || this.isInWater()))
+        {
+            this.setDeltaMovement(this.getWheelsDeltaMovement());
+        }
+        if (this.delayticks > 0 && this.isVehicle())
+        {
+            --this.delayticks;
+        }
+
+        if (this.renderupdateticks-- <= 0)
+        {
+            this.updateMachineRender();
+            this.renderupdateticks = SiegeMachines.RENDER_UPDATE_TIME;
+        }
+
+        super.tick();
+    }
+
+    @Override
+    public void startShooting(PlayerEntity player)
+    {
+        if (this.delayticks <= 0 && this.useticks <= 0)
+        {
+            if (!this.level.isClientSide())
+            {
+                this.level.playSound(null, this.getX(), this.getY(), this.getZ(), SoundTypes.FUSE.get(), SoundCategory.BLOCKS, this.getVolumeFromDist(0.5f, 6.0f, this.distanceTo(player)), 0.8f);
+            }
+            this.useticks = this.type.usetime;
+        }
+    }
+
+    @Override
+    public void shoot()
+    {
+        if (!level.isClientSide())
+        {
+            super.shoot();
+            this.setDeltaMovement(this.getDeltaMovement().subtract(this.getShotView().scale(0.25)));
+            this.hasImpulse = true;
+            this.inventory.shrinkItem(Items.GUNPOWDER);
+        }
+        else
+        {
+            this.blowParticles(ParticleTypes.FLAME, 0.035, 25);
+            this.blowParticles(ParticleTypes.CLOUD, 0.2, 60);
+            Vector3d pos = this.position();
+            this.level.playLocalSound(pos.x, pos.y, pos.z, SoundTypes.MORTAR_SHOOTING.get(), SoundCategory.BLOCKS, 1.5f/*this.getVolumeFromDist(1.5f, 64.0f, this.distanceTo(player))*/, 0.85f + this.level.random.nextFloat() * 0.3f, false);
+        }
+
+        this.delayticks = this.type.specs.delaytime.get();
+    }
+
+    public double getWheelsSpeed()
+    {
+        if (this.isOnGround())
+        {
+            return this.getViewVector(5.0f).multiply(1, 0, 1).dot(this.getDeltaMovement());
+        }
+
+        return 0.0;
+    }
+
+    public Vector3d getWheelsDeltaMovement()
+    {
+        if (this.isOnGround())
+        {
+            Vector3d view = this.getViewVector(1.0f);
+            Vector3d movement = this.getDeltaMovement();
+
+            double d0 = movement.x * view.x + movement.z * view.z;
+
+            double d1 = d0 * view.x;
+            double d2 = 0.0;
+            double d3 = d0 * view.z;
+
+            return new Vector3d(d1, d2, d3);
+        }
+
+        return Vector3d.ZERO;
+    }
+
+    @Override
+    @OnlyIn(Dist.CLIENT)
+    public Crosshair createCrosshair()
+    {
+        return new ReloadingCrosshair();
+    }
+
+    @Override
+    public Item getMachineItem()
+    {
+        return null;
+//        return ModItems.CULVERIN.get();
+    }
+}

src/main/java/magistu/siegemachines/entity/machine/Machine.java

@@ -0,0 +1,862 @@
+package magistu.siegemachines.entity.machine;
+
+import magistu.siegemachines.SiegeMachines;
+import magistu.siegemachines.gui.MachineContainer;
+import magistu.siegemachines.item.ModItems;
+import magistu.siegemachines.network.PacketHandler;
+import magistu.siegemachines.network.PacketMachine;
+import net.minecraft.advancements.CriteriaTriggers;
+import net.minecraft.block.HoneyBlock;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityType;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.entity.MobEntity;
+import net.minecraft.entity.ai.attributes.AttributeModifierMap;
+import net.minecraft.entity.ai.attributes.Attributes;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.entity.player.PlayerInventory;
+import net.minecraft.entity.player.ServerPlayerEntity;
+import net.minecraft.entity.projectile.AbstractArrowEntity;
+import net.minecraft.inventory.Inventory;
+import net.minecraft.inventory.container.Container;
+import net.minecraft.inventory.container.INamedContainerProvider;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.Items;
+import net.minecraft.nbt.CompoundNBT;
+import net.minecraft.nbt.ListNBT;
+import net.minecraft.particles.ParticleTypes;
+import net.minecraft.potion.Effects;
+import net.minecraft.util.*;
+import net.minecraft.util.math.MathHelper;
+import net.minecraft.util.math.vector.Vector3d;
+import net.minecraft.world.World;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import net.minecraftforge.fml.network.NetworkHooks;
+import org.jetbrains.annotations.NotNull;
+
+import javax.annotation.Nullable;
+import java.util.Arrays;
+import java.util.Random;
+
+public abstract class Machine extends MobEntity implements INamedContainerProvider
+{
+	public MachineInventory inventory;
+
+	public final MachineType type;
+
+	private float turretpitch = -25.0f;
+	private float turretpitchprev = this.turretpitch;
+	protected float turretpitchdest = this.turretpitch;
+	private float turretyaw = 0.0f;
+	private float turretyawprev = this.turretyaw;
+	protected float turretyawdest = this.turretyaw;
+	protected float yawdest = this.yRot;
+
+	public int useticks = -1;
+	public int delayticks;
+	protected int renderupdateticks = 0;
+	public int deploymentticks = 0;
+
+	protected Machine(EntityType<? extends MobEntity> entitytype, World level, MachineType type)
+    {
+        super(entitytype, level);
+		this.type = type;
+		this.delayticks = this.type.specs.delaytime.get();
+		inventory = new MachineInventory(this.type.containersize);
+		
+		this.getAttribute(Attributes.MAX_HEALTH).setBaseValue(type.specs.durability.get());
+		this.setHealth(type.specs.durability.get());
+	}
+
+	public static AttributeModifierMap.MutableAttribute setEntityAttributes(MachineType type)
+	{
+		return MobEntity.createMobAttributes()
+				.add(Attributes.MAX_HEALTH, type.specs.durability.get())
+				.add(Attributes.KNOCKBACK_RESISTANCE, 0.5F)
+				.add(Attributes.MOVEMENT_SPEED, 0.0D)
+				.add(Attributes.ATTACK_DAMAGE, 0.0D)
+				.add(Attributes.FOLLOW_RANGE, 0.0D);
+	}
+
+	public ItemStack getMachineItemWithData()
+	{
+		ItemStack stack = new ItemStack(this.getMachineItem());
+        CompoundNBT nbt = this.saveWithoutId(new CompoundNBT());
+        nbt.remove("Pos");
+        nbt.remove("Motion");
+        nbt.remove("FallDistance");
+        nbt.remove("Fire");
+        nbt.remove("Air");
+        nbt.remove("OnGround");
+        nbt.remove("Invulnerable");
+        nbt.remove("PortalCooldown");
+        nbt.remove("UUID");
+        nbt.remove("Passengers");
+        nbt.remove("DelayTicks");
+        nbt.remove("UseTicks");
+        stack.addTagElement("EntityTag", nbt);
+        return stack;
+	}
+
+	@Override
+	public boolean isInvulnerableTo(DamageSource damagesource)
+	{
+		return damagesource == DamageSource.CACTUS ||
+				damagesource == DamageSource.WITHER ||
+				damagesource == DamageSource.MAGIC ||
+				damagesource == DamageSource.DROWN ||
+				damagesource == DamageSource.STARVE ||
+				super.isInvulnerableTo(damagesource);
+	}
+
+	public float adjustDamage(DamageSource damagesource, float f)
+	{
+		if (damagesource.isFire())
+		{
+			f *= 1.5f;
+		}
+		if (damagesource.isExplosion())
+		{
+			f *= 1.25f;
+		}
+		if (damagesource.getEntity() instanceof AbstractArrowEntity)
+		{
+			f *= 0.5;
+		}
+		return f;
+	}
+
+	public abstract Item getMachineItem();
+
+	@Override
+	public void tick()
+	{
+		if (this.deploymentticks > 0)
+		{
+			this.deploymentticks--;
+		}
+		super.tick();
+	}
+
+	@Override
+	public boolean hurt(@NotNull DamageSource damagesource, float f)
+	{
+		if (!net.minecraftforge.common.ForgeHooks.onLivingAttack(this, damagesource, f)) return false;
+		if (damagesource.getEntity() instanceof PlayerEntity && !damagesource.isProjectile() && !damagesource.isExplosion() && !damagesource.isMagic() && this.getPassengers().isEmpty())
+        {
+            this.spawnAtLocation(this.getMachineItemWithData());
+            this.remove();
+            return false;
+        }
+		if (this.isInvulnerableTo(damagesource))
+		{
+			return false;
+		}
+		else if (this.level.isClientSide)
+		{
+			return false;
+		}
+		else if (this.isDeadOrDying())
+		{
+			return false;
+		}
+		else if (damagesource.isFire() && this.hasEffect(Effects.FIRE_RESISTANCE))
+		{
+			return false;
+		}
+		else
+		{
+			f = adjustDamage(damagesource, f);
+
+			this.noActionTime = 0;
+
+			this.animationSpeed = 1.5F;
+			boolean flag1 = true;
+			if ((float) this.invulnerableTime > 10.0F)
+			{
+				if (f <= this.lastHurt)
+				{
+					return false;
+				}
+
+				this.actuallyHurt(damagesource, f - this.lastHurt);
+				this.lastHurt = f;
+				flag1 = false;
+			}
+			else
+			{
+				this.lastHurt = f;
+				this.invulnerableTime = 20;
+				this.actuallyHurt(damagesource, f);
+				this.hurtDuration = 10;
+				this.hurtTime = this.hurtDuration;
+			}
+
+			this.hurtDir = 0.0F;
+			Entity entity1 = damagesource.getEntity();
+			if (entity1 != null)
+			{
+				if (entity1 instanceof LivingEntity)
+				{
+					this.setLastHurtByMob((LivingEntity) entity1);
+				}
+
+				if (entity1 instanceof PlayerEntity)
+				{
+					this.lastHurtByPlayerTime = 100;
+					this.lastHurtByPlayer = (PlayerEntity) entity1;
+				}
+				else if (entity1 instanceof net.minecraft.entity.passive.TameableEntity)
+				{
+					net.minecraft.entity.passive.TameableEntity wolfentity = (net.minecraft.entity.passive.TameableEntity) entity1;
+					if (wolfentity.isTame())
+					{
+						this.lastHurtByPlayerTime = 100;
+						LivingEntity livingentity = wolfentity.getOwner();
+						if (livingentity != null && livingentity.getType() == EntityType.PLAYER)
+						{
+							this.lastHurtByPlayer = (PlayerEntity) livingentity;
+						}
+						else
+						{
+							this.lastHurtByPlayer = null;
+						}
+					}
+				}
+			}
+
+			if (flag1)
+			{
+				if (damagesource instanceof EntityDamageSource && ((EntityDamageSource) damagesource).isThorns())
+				{
+					this.level.broadcastEntityEvent(this, (byte) 33);
+				}
+				else
+				{
+					byte b0;
+					if (damagesource.isFire())
+					{
+						b0 = 37;
+					}
+					else if (damagesource == DamageSource.SWEET_BERRY_BUSH)
+					{
+						b0 = 44;
+					}
+					else
+					{
+						b0 = 2;
+					}
+
+					this.level.broadcastEntityEvent(this, b0);
+				}
+
+				this.markHurt();
+
+				if (entity1 != null)
+				{
+					double d1 = entity1.getX() - this.getX();
+
+					double d0;
+					for (d0 = entity1.getZ() - this.getZ(); d1 * d1 + d0 * d0 < 1.0E-4D; d0 = (Math.random() - Math.random()) * 0.01D)
+					{
+						d1 = (Math.random() - Math.random()) * 0.01D;
+					}
+
+					this.hurtDir = (float) (MathHelper.atan2(d0, d1) * (double) (180F / (float) Math.PI) - (double) this.yRot);
+				}
+				else
+				{
+					this.hurtDir = (float) ((int) (Math.random() * 2.0D) * 180);
+				}
+			}
+
+			if (this.isDeadOrDying())
+			{
+				SoundEvent soundevent = this.getDeathSound();
+				if (flag1 && soundevent != null)
+				{
+					this.playSound(soundevent, this.getSoundVolume(), this.getVoicePitch());
+				}
+
+				this.die(damagesource);
+			}
+			else if (flag1)
+			{
+				this.playHurtSound(damagesource);
+			}
+
+			if (entity1 instanceof ServerPlayerEntity)
+			{
+				CriteriaTriggers.PLAYER_HURT_ENTITY.trigger((ServerPlayerEntity) entity1, this, damagesource, f, f, false);
+			}
+
+			return true;
+		}
+	}
+
+	@Override
+	@Nullable
+	protected SoundEvent getHurtSound(@NotNull DamageSource p_184601_1_)
+	{
+		return null;
+	}
+
+	@Override
+	@Nullable
+	protected SoundEvent getDeathSound()
+	{
+		return null;
+	}
+
+	@Override
+	protected @NotNull SoundEvent getFallDamageSound(int n)
+	{
+		return SoundEvents.WOOD_FALL;
+	}
+
+	@Override
+	public boolean removeWhenFarAway(double p_213397_1_)
+	{
+		return false;
+	}
+
+    @Nullable
+	@Override
+	public Entity getControllingPassenger()
+    {
+		return this.getPassengers().isEmpty() ? null : this.getPassengers().get(0);
+	}
+
+    @Override
+	public boolean canBeControlledByRider()
+    {
+		return true;
+	}
+
+	@Override
+	public void addAdditionalSaveData(@NotNull CompoundNBT nbt)
+	{
+		super.addAdditionalSaveData(nbt);
+
+		ListNBT listnbt = new ListNBT();
+    	for(ItemStack itemstack : this.inventory.items)
+		{
+    		CompoundNBT compoundnbt = new CompoundNBT();
+    		if (!itemstack.isEmpty())
+			{
+    			itemstack.save(compoundnbt);
+    		}
+    		listnbt.add(compoundnbt);
+    	}
+    	nbt.put("Items", listnbt);
+		nbt.put("TurretRotations", this.newFloatList(this.turretpitch, this.turretyaw));
+		nbt.putInt("DealyTicks", this.delayticks);
+		nbt.putInt("UseTicks", this.useticks);
+	}
+
+	@Override
+	protected void dropCustomDeathLoot(DamageSource p_213333_1_, int p_213333_2_, boolean p_213333_3_)
+	{
+		super.dropCustomDeathLoot(p_213333_1_, p_213333_2_, p_213333_3_);
+		this.dropWreckage(p_213333_1_, p_213333_2_, p_213333_3_);
+		this.inventory.items.forEach(this::spawnAtLocation);
+		this.inventory.removeAllItems();
+	}
+
+	protected void dropWreckage(DamageSource p_213333_1_, int p_213333_2_, boolean p_213333_3_)
+	{
+		if (p_213333_1_.isFire())
+		{
+			Arrays.stream(this.type.wreckage).forEach(itemstack -> {
+				if (itemstack.getItem().equals(Items.OAK_PLANKS))
+				{
+					itemstack = new ItemStack(Items.CHARCOAL, (int) (0.25f * new Random().nextInt(itemstack.getCount() + 1) - 1));
+				}
+				else if (!itemstack.getItem().equals(Items.STICK) && !itemstack.getItem().equals(ModItems.BEAM.get()))
+				{
+					itemstack.setCount(new Random().nextInt(itemstack.getCount() + 1) - 1);
+				}
+				spawnAtLocation(itemstack);
+			});
+
+			return;
+		}
+		Arrays.stream(this.type.wreckage).forEach(itemstack -> {
+			itemstack.setCount(new Random().nextInt(itemstack.getCount() + 1) - 1);
+			spawnAtLocation(itemstack);
+		});
+	}
+
+    public void remove()
+    {
+        if (!this.removed && !this.dead)
+        {
+            this.dead = true;
+            this.level.broadcastEntityEvent(this, (byte)3);
+        }
+        super.remove();
+    }
+
+	@Override
+	@OnlyIn(Dist.CLIENT)
+	public void handleEntityEvent(byte p_70103_1_)
+	{
+		switch(p_70103_1_)
+		{
+			case 2:
+			case 33:
+			case 36:
+			case 37:
+			case 44:
+				boolean flag1 = p_70103_1_ == 33;
+				boolean flag2 = p_70103_1_ == 36;
+				boolean flag3 = p_70103_1_ == 37;
+				boolean flag = p_70103_1_ == 44;
+				this.animationSpeed = 1.5F;
+				this.invulnerableTime = 20;
+				this.hurtDuration = 10;
+				this.hurtTime = this.hurtDuration;
+				this.hurtDir = 0.0F;
+				if (flag1)
+				{
+					this.playSound(SoundEvents.THORNS_HIT, this.getSoundVolume(), (this.random.nextFloat() - this.random.nextFloat()) * 0.2F + 1.0F);
+				}
+
+				DamageSource damagesource;
+				if (flag3)
+				{
+					damagesource = DamageSource.ON_FIRE;
+				} else if (flag2)
+				{
+					damagesource = DamageSource.DROWN;
+				} else if (flag)
+				{
+					damagesource = DamageSource.SWEET_BERRY_BUSH;
+				} else
+				{
+					damagesource = DamageSource.GENERIC;
+				}
+
+				SoundEvent soundevent1 = this.getHurtSound(damagesource);
+				if (soundevent1 != null)
+				{
+					this.playSound(soundevent1, this.getSoundVolume(), (this.random.nextFloat() - this.random.nextFloat()) * 0.2F + 1.0F);
+				}
+
+				this.hurt(DamageSource.GENERIC, 0.0F);
+				break;
+			case 3:
+				SoundEvent soundevent = this.getDeathSound();
+				if (soundevent != null)
+				{
+					this.playSound(soundevent, this.getSoundVolume(), (this.random.nextFloat() - this.random.nextFloat()) * 0.2F + 1.0F);
+				}
+				this.setHealth(0.0F);
+				this.remove();
+				break;
+			case 4:
+			case 5:
+			case 6:
+			case 7:
+			case 8:
+			case 9:
+			case 10:
+			case 11:
+			case 12:
+			case 13:
+			case 14:
+			case 15:
+			case 16:
+			case 17:
+			case 18:
+			case 19:
+			case 20:
+			case 21:
+			case 22:
+			case 23:
+			case 24:
+			case 25:
+			case 26:
+			case 27:
+			case 28:
+			case 31:
+			case 32:
+			case 34:
+			case 35:
+			case 38:
+			case 39:
+			case 40:
+			case 41:
+			case 42:
+			case 43:
+			case 45:
+			case 53:
+			default:
+				super.handleEntityEvent(p_70103_1_);
+				break;
+			case 29:
+			case 30:
+			case 46:
+				int i = 128;
+
+				for (int j = 0; j < 128; ++j)
+				{
+					double d0 = (double) j / 127.0D;
+					float f = (this.random.nextFloat() - 0.5F) * 0.2F;
+					float f1 = (this.random.nextFloat() - 0.5F) * 0.2F;
+					float f2 = (this.random.nextFloat() - 0.5F) * 0.2F;
+					double d1 = MathHelper.lerp(d0, this.xo, this.getX()) + (this.random.nextDouble() - 0.5D) * (double) this.getBbWidth() * 2.0D;
+					double d2 = MathHelper.lerp(d0, this.yo, this.getY()) + this.random.nextDouble() * (double) this.getBbHeight();
+					double d3 = MathHelper.lerp(d0, this.zo, this.getZ()) + (this.random.nextDouble() - 0.5D) * (double) this.getBbWidth() * 2.0D;
+					this.level.addParticle(ParticleTypes.PORTAL, d1, d2, d3, (double) f, (double) f1, (double) f2);
+				}
+				break;
+			case 54:
+				HoneyBlock.showJumpParticles(this);
+				break;
+		}
+	}
+
+	@Override
+	public void readAdditionalSaveData(@NotNull CompoundNBT nbt)
+	{
+		super.readAdditionalSaveData(nbt);
+		if (nbt.contains("Items", 9))
+		{
+        	ListNBT listnbt = nbt.getList("Items", 10);
+
+    		for(int i = 0; i < this.inventory.items.size(); ++i)
+			{
+         		this.inventory.items.set(i, ItemStack.of(listnbt.getCompound(i)));
+    		}
+    	}
+		if (nbt.contains("TurretRotations", 5))
+		{
+			ListNBT turretrotations = nbt.getList("TurretRotations", 5);
+			setTurretRotations(turretrotations.getFloat(0), turretrotations.getFloat(1));
+		}
+		if (nbt.contains("DealyTicks"))
+		{
+			this.delayticks = nbt.getInt("DealyTicks");
+		}
+		if (nbt.contains("UseTicks"))
+		{
+			this.useticks = nbt.getInt("UseTicks");
+		}
+	}
+
+	public float getGlobalTurretYaw()
+	{
+		return MathHelper.lerp(0.5f, this.yRotO, this.yRot) + MathHelper.lerp(0.5f, this.turretyawprev, this.turretyaw);
+	}
+
+	public float getYaw()
+	{
+		return this.yRot;
+	}
+	public void setYaw(float yaw)
+	{
+		this.yRot = yaw;
+		this.yRotO = this.yRot;
+		this.yBodyRot = this.yRot;
+		this.yHeadRot = this.yBodyRot;
+
+		this.setRot(this.yRot, this.xRot);
+	}
+
+	public float getYawDest()
+	{
+		return this.yawdest;
+	}
+
+	public void setYawDest(float yaw)
+	{
+		this.yawdest = yaw;
+	}
+
+	public float getTurretPitch(float f)
+	{
+		return MathHelper.lerp(f, this.turretpitchprev, this.turretpitch);
+	}
+
+	public float getTurretYaw(float f)
+	{
+		return MathHelper.lerp(f, this.turretyawprev, this.turretyaw);
+	}
+
+	public float getTurretPitch()
+	{
+		return this.getTurretPitch(0.5f);
+	}
+
+	public float getTurretYaw()
+	{
+		return this.getTurretYaw(0.5f);
+	}
+
+	public void setTurretRotations(float pitch, float yaw)
+	{
+		this.turretpitchprev = this.turretpitch;
+		this.turretyawprev = this.turretyaw;
+		this.turretpitch = pitch;
+		this.turretyaw = yaw;
+	}
+
+	public float getTurretPitchDest()
+	{
+		return this.turretpitchdest;
+	}
+
+	public float getTurretYawDest()
+	{
+		return this.turretyawdest;
+	}
+
+	public void setTurretRotationsDest(float pitch, float yaw)
+	{
+		this.turretpitchdest = pitch;
+		this.turretyawdest = yaw;
+	}
+
+	public void updateMachineRender()
+	{
+		if (!this.level.isClientSide())
+		{
+			PacketHandler.sendPacketToAllInArea(new PacketMachine(
+					this.getId(),
+					this.delayticks,
+					this.useticks,
+					this.turretpitch,
+					this.turretyaw), this.blockPosition(), SiegeMachines.RENDER_UPDATE_RANGE_SQR);
+		}
+	}
+
+	public void updateYaw()
+	{
+		float newyaw = this.turn(this.getYaw(), this.getYawDest(), this.type.rotationspeed);
+
+		if (this.getYaw() != newyaw)
+			this.setYaw(newyaw);
+	}
+
+	public void updateTurretRotations()
+	{
+		float newyaw = this.turn(this.getTurretYaw(), this.getTurretYawDest(), this.type.turretspeed, this.type.turretminyaw, this.type.turretmaxyaw);
+		boolean shouldrotate = this.checkYaw(newyaw, this.getTurretYaw(), this.type.turretspeed, this.type.turretminyaw, this.type.turretmaxyaw);
+		float newpitch = shouldrotate ? this.turn(this.getTurretPitch(), this.getTurretPitchDest(), this.type.turretspeed, this.type.turretminpitch, this.type.turretmaxpitch) : this.getTurretPitch();
+
+		if (this.turretpitch != newpitch || this.turretyaw != newyaw)
+			this.setTurretRotations(newpitch, newyaw);
+	}
+
+	public boolean checkYaw(float yaw, float currentyaw, float speed, float minyaw, float maxuaw)
+	{
+		return !this.type.yawfirst || Math.abs(yaw - currentyaw) <= speed / 2 || yaw <= this.type.turretminyaw || yaw >= this.type.turretmaxyaw;
+	}
+
+	public float turn(float rotation, float rotationdest, float speed)
+	{
+		return this.turn(rotation, rotationdest, speed, -180, 180);
+	}
+
+	public float turn(float rotation, float rotationdest, float speed, float minrotation, float maxrotation)
+	{
+		boolean haslimit = maxrotation - minrotation < 360;
+
+		float deltarotation = rotationdest - rotation;
+		deltarotation = MathHelper.wrapDegrees(deltarotation);
+
+		float newrotation;
+		if (deltarotation > speed / 2)
+		{
+			newrotation = rotation + speed;
+		}
+		else if (deltarotation < -speed / 2)
+		{
+			newrotation = rotation - speed;
+		}
+		else
+		{
+			newrotation = rotation + deltarotation / 2;
+		}
+
+		if (haslimit)
+		{
+			if (newrotation > -minrotation)
+			{
+				newrotation = -minrotation;
+			}
+			if (newrotation < -maxrotation)
+			{
+				newrotation = -maxrotation;
+			}
+		}
+
+		return newrotation;
+	}
+
+	protected static Vector3d applyRotations(Vector3d vec, double pitch, double yaw)
+	{
+		double d0 = vec.x * Math.cos(yaw) - vec.y * Math.sin(pitch) * Math.sin(yaw) - vec.z * Math.sin(yaw) * Math.cos(pitch);
+		double d1 = vec.y * Math.cos(pitch) - vec.z * Math.sin(pitch);
+		double d2 = vec.x * Math.sin(yaw) + vec.y * Math.sin(pitch) * Math.cos(yaw) + vec.z * Math.cos(yaw) * Math.cos(pitch);
+		return new Vector3d(d0, d1, d2);
+	}
+
+	protected float getVolumeFromDist(float maxvolume, float maxdist, float dist)
+	{
+		return maxvolume * Math.max(maxdist - dist, 0.0f) / maxdist;
+	}
+
+	public abstract void use(PlayerEntity player);
+
+	public abstract void useRealise();
+
+	@Override
+	public Container createMenu(int id, @NotNull PlayerInventory inv, @NotNull PlayerEntity player)
+	{
+		return new MachineContainer(id, inv, this);
+	}
+
+	public void openInventoryGui()
+	{
+		Entity passenger = this.getControllingPassenger();
+		if (passenger instanceof ServerPlayerEntity)
+		{
+			this.stopRiding();
+			NetworkHooks.openGui((ServerPlayerEntity) passenger, this, this.blockPosition());
+		}
+	}
+
+	@Override
+	public @NotNull Vector3d getDismountLocationForPassenger(LivingEntity entity)
+	{
+		double yaw = (this.getGlobalTurretYaw()) * Math.PI / 180.0;
+
+		return this.position().add(applyRotations(this.type.passengerpos, 0.0, yaw));
+	}
+
+	@Override
+	public boolean shouldRiderSit()
+	{
+		return false;
+	}
+
+	@Override
+    public void positionRider(@NotNull Entity entity)
+    {
+        IMoveCallback setpos = Entity::setPos;
+        if (this.hasPassenger(entity))
+        {
+            double yaw = (this.getGlobalTurretYaw()) * Math.PI / 180.0;
+
+            Vector3d pos = this.position().add(applyRotations(this.type.passengerpos, 0.0, yaw));
+            setpos.accept(entity, pos.x, pos.y, pos.z);
+        }
+    }
+	
+	public class MachineInventory extends Inventory
+	{
+		private final int containersize;
+		public NonNullList<ItemStack> items;
+
+		public MachineInventory(int containersize)
+		{
+			this.containersize = containersize;
+			items = NonNullList.withSize(this.containersize, ItemStack.EMPTY);
+		}
+		
+		@Override
+		public int getContainerSize()
+		{
+			return this.containersize;
+		}
+
+		@Override
+		public boolean isEmpty()
+		{
+			return false;
+		}
+
+		@Override
+		public @NotNull ItemStack getItem(int id)
+		{
+			return this.items.get(id);
+		}
+
+		@Override
+		public @NotNull ItemStack removeItem(int id, int p_70298_2_)
+		{
+			return this.items.set(id, ItemStack.EMPTY);
+		}
+
+		@Override
+		public @NotNull ItemStack removeItemNoUpdate(int id)
+		{
+			return this.items.remove(id);
+		}
+
+		@Override
+		public void setItem(int id, @NotNull ItemStack item)
+		{
+			this.items.set(id, item);
+		}
+
+		@Override
+		public void setChanged()
+		{
+
+		}
+
+		@Override
+		public boolean stillValid(@NotNull PlayerEntity player)
+		{
+			return true;
+		}
+
+		@Override
+		public void clearContent()
+		{
+			this.items = NonNullList.withSize(this.containersize, ItemStack.EMPTY);
+		}
+
+		public boolean containsItem(Item item)
+    	{
+        	return this.items.stream().anyMatch(itemstack -> itemstack.getItem().equals(item));
+    	}
+
+		public void putItem(Item item)
+    	{
+        	for (int i = 0; i < this.items.size(); ++i)
+			{
+				ItemStack itemstack = this.items.get(i);
+				if (itemstack.isEmpty())
+				{
+					this.items.set(i, new ItemStack(item));
+					break;
+				}
+				if (itemstack.getItem().equals(item) && itemstack.getCount() < itemstack.getMaxStackSize())
+				{
+					itemstack.setCount(itemstack.getCount() + 1);
+					break;
+				}
+			}
+    	}
+
+		public int shrinkItem(Item item)
+    	{
+        	for (int i = 0; i < this.containersize; ++i)
+			{
+				ItemStack itemstack = this.items.get(i);
+				if (itemstack.getItem().equals(item))
+				{
+					itemstack.shrink(1);
+					return i;
+				}
+			}
+			return -1;
+    	}
+	}
+}

src/main/java/magistu/siegemachines/entity/machine/MachinePartEntity.java

@@ -0,0 +1,54 @@
+package magistu.siegemachines.entity.machine;
+
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntitySize;
+import net.minecraft.entity.Pose;
+import net.minecraft.nbt.CompoundNBT;
+import net.minecraft.network.IPacket;
+import net.minecraft.util.DamageSource;
+import org.jetbrains.annotations.NotNull;
+
+public class MachinePartEntity extends net.minecraftforge.entity.PartEntity<Machine>
+{
+    public final Machine parentmob;
+    public final String name;
+    private final EntitySize size;
+
+    public MachinePartEntity(Machine parent, String name, float width, float height)
+    {
+        super(parent);
+        this.size = EntitySize.scalable(width, height);
+        this.refreshDimensions();
+        this.parentmob = parent;
+        this.name = name;
+    }
+
+    @Override
+    protected void defineSynchedData() {}
+
+    @Override
+    protected void readAdditionalSaveData(@NotNull CompoundNBT p_70037_1_) {}
+
+    @Override
+    protected void addAdditionalSaveData(@NotNull CompoundNBT p_213281_1_) {}
+
+    public boolean hurt(@NotNull DamageSource source, float value)
+    {
+        return !this.isInvulnerableTo(source) && this.parentmob.hurt(source, value);
+    }
+
+    public boolean is(@NotNull Entity entity)
+    {
+        return this == entity || this.parentmob == entity;
+    }
+
+    public IPacket<?> getAddEntityPacket()
+    {
+        throw new UnsupportedOperationException();
+    }
+
+    public @NotNull EntitySize getDimensions(@NotNull Pose p_213305_1_)
+    {
+        return this.size;
+    }
+}

src/main/java/magistu/siegemachines/entity/machine/MachineType.java

@@ -0,0 +1,96 @@
+package magistu.siegemachines.entity.machine;
+
+import magistu.siegemachines.config.SiegeMachineSpecs;
+import magistu.siegemachines.config.SpecsConfig;
+import magistu.siegemachines.entity.projectile.ProjectileBuilder;
+import magistu.siegemachines.item.ModItems;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.Items;
+import net.minecraft.util.math.vector.Vector3d;
+
+public enum MachineType
+{
+    MORTAR(SpecsConfig.MORTAR, 18, 0.0f, 85.0f, 0.0f, 0.0f, 0.5f, 0.5f, true, 10, 10,
+            new Vector3d(-0.5, 0.0, -20.0).scale(1 / 16.0), new Vector3d(0.0, 17.0, 7.0).scale(1 / 16.0), new Vector3d(0.0, 0.0, 12.0).scale(1 / 16.0),
+            ProjectileBuilder.CANNON_AMMO, true,
+            new ItemStack[] {new ItemStack(Items.OAK_PLANKS, 2), new ItemStack(ModItems.BEAM.get(), 1), new ItemStack(Items.STICK, 5), new ItemStack(Items.IRON_NUGGET, 21)}),
+    CULVERIN(SpecsConfig.CULVERIN, 9, 0.0f, 85.0f, 0.0f, 0.0f, 0.5f, 0.5f, true, 10, 10,
+            new Vector3d(-0.5, 0.0, -20.0).scale(1 / 16.0), new Vector3d(0.0, 17.0, 7.0).scale(1 / 16.0), new Vector3d(0.0, 0.0, 12.0).scale(1 / 16.0),
+            ProjectileBuilder.CANNON_AMMO, true,
+            new ItemStack[] {new ItemStack(Items.OAK_PLANKS, 2), new ItemStack(ModItems.BEAM.get(), 1), new ItemStack(Items.STICK, 5), new ItemStack(Items.IRON_NUGGET, 21)}),
+    TREBUCHET(SpecsConfig.TREBUCHET, 9, -45.0f, 75.0f, 0.0f, 0.0f, 0.05f, 0.5f, true, 38, 137,
+            new Vector3d(-34.0, 0.0, -94.0).scale(1 / 16.0), new Vector3d(0.0, 19.0, -3.0), new Vector3d(0.0, 10.0, -1.0),
+            ProjectileBuilder.GIANT_THROWING_AMMO, false,
+            new ItemStack[] {new ItemStack(Items.OAK_PLANKS, 8), new ItemStack(ModItems.BEAM.get(), 12), new ItemStack(Items.STICK, 20), new ItemStack(Items.IRON_NUGGET, 36), new ItemStack(Items.COBBLESTONE, 2)}),
+    CATAPULT(SpecsConfig.CATAPULT, 9, 0.0f, 75.0f, 0.0f, 0.0f, 0.2f, 1.0f, true, 2, 10,
+            new Vector3d(30.0, 0.0, -40.0).scale(1 / 16.0), new Vector3d(0.0, 51.0, -5.0).scale(1 / 16.0), new Vector3d(0.0, 0.0, 0.0),
+            ProjectileBuilder.THROWING_AMMO, false,
+            new ItemStack[] {new ItemStack(Items.OAK_PLANKS, 5), new ItemStack(ModItems.BEAM.get(), 6), new ItemStack(Items.STICK, 10), new ItemStack(Items.IRON_NUGGET, 14)}),
+    BALLISTA(SpecsConfig.BALLISTA, 9, -30.0f, 60.0f, -180.0f, 180.0f, 0.0f, 3.0f, false, 1, 20,
+            new Vector3d(0.0, 0.0, -30.0).scale(1 / 16.0), new Vector3d(0.0, 22.5, 0.0).scale(1 / 16.0), new Vector3d(0.0, 0.0, 17.0).scale(1 / 16.0),
+            ProjectileBuilder.BALLISTA_AMMO, false,
+            new ItemStack[] {new ItemStack(Items.OAK_PLANKS, 2), new ItemStack(ModItems.BEAM.get(), 1), new ItemStack(Items.STICK, 5), new ItemStack(Items.IRON_NUGGET, 8)}),
+    BATTERING_RAM(SpecsConfig.BATTERING_RAM, 9, 0.0f, 0.0f, 0.0f, 0.0f, 0.1f, 0.0f, false, 5, 5,
+            new Vector3d(12.0, 0.0, -48.0).scale(1 / 16.0), new Vector3d(0.0, 26.0, 36.0).scale(1 / 16.0), new Vector3d(0.0, 0.0, 32.0).scale(1 / 16.0),
+            ProjectileBuilder.NO_AMMO, false,
+            new ItemStack[] {new ItemStack(Items.OAK_PLANKS, 6), new ItemStack(ModItems.BEAM.get(), 8), new ItemStack(Items.STICK, 12), new ItemStack(Items.IRON_NUGGET, 8)});
+
+    public final SiegeMachineSpecs specs;
+    public final int containersize;
+    public final float turretminpitch;
+    public final float turretmaxpitch;
+    public final float turretminyaw;
+    public final float turretmaxyaw;
+    public final float rotationspeed;
+    public final float turretspeed;
+    public final boolean yawfirst;
+    public final int userealisetime;
+    public final int usetime;
+
+    public final Vector3d passengerpos;
+    public final Vector3d turretpivot;
+    public final Vector3d turretvector;
+
+    public final ProjectileBuilder[] ammo;
+    public final boolean usesgunpowder;
+    
+    public final ItemStack[] wreckage;
+
+    MachineType(
+            SiegeMachineSpecs specs,
+            int containersize,
+            float turretminpitch,
+            float turretmaxpitch,
+            float turretminyaw,
+            float turretmaxyaw,
+            float rotationspeed,
+            float turretspeed,
+            boolean yawfirst,
+            int shootingtime,
+            int usetime,
+            Vector3d passengerpos,
+            Vector3d turretpivot,
+            Vector3d turretvector,
+            ProjectileBuilder[] ammo,
+            boolean usesgunpowder,
+            ItemStack[] wreckage)
+    {
+        this.specs = specs;
+        this.containersize = containersize;
+        this.turretminpitch = turretminpitch;
+        this.turretmaxpitch = turretmaxpitch;
+        this.turretminyaw = turretminyaw;
+        this.turretmaxyaw = turretmaxyaw;
+        this.rotationspeed = rotationspeed;
+        this.turretspeed = turretspeed;
+        this.yawfirst = yawfirst;
+        this.userealisetime = shootingtime;
+        this.usetime = usetime;
+        this.passengerpos = passengerpos;
+        this.turretpivot = turretpivot;
+        this.turretvector = turretvector;
+        this.ammo = ammo;
+        this.usesgunpowder = usesgunpowder;
+        this.wreckage = wreckage;
+    }
+}

src/main/java/magistu/siegemachines/entity/machine/Mortar.java

@@ -0,0 +1,277 @@
+package magistu.siegemachines.entity.machine;
+
+import magistu.siegemachines.SiegeMachines;
+import magistu.siegemachines.client.SoundTypes;
+import magistu.siegemachines.entity.IReloading;
+import magistu.siegemachines.entity.projectile.Cannonball;
+import magistu.siegemachines.entity.projectile.Missile;
+import magistu.siegemachines.gui.Crosshair;
+import magistu.siegemachines.gui.ReloadingCrosshair;
+import magistu.siegemachines.item.ModItems;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityType;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.entity.MobEntity;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.entity.projectile.ProjectileEntity;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.Items;
+import net.minecraft.particles.ParticleTypes;
+import net.minecraft.util.ActionResultType;
+import net.minecraft.util.Hand;
+import net.minecraft.util.SoundCategory;
+import net.minecraft.util.math.vector.Vector3d;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.util.text.TranslationTextComponent;
+import net.minecraft.world.World;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import software.bernie.geckolib3.core.IAnimatable;
+import software.bernie.geckolib3.core.PlayState;
+import software.bernie.geckolib3.core.builder.AnimationBuilder;
+import software.bernie.geckolib3.core.controller.AnimationController;
+import software.bernie.geckolib3.core.event.SoundKeyframeEvent;
+import software.bernie.geckolib3.core.event.predicate.AnimationEvent;
+import software.bernie.geckolib3.core.manager.AnimationData;
+import software.bernie.geckolib3.core.manager.AnimationFactory;
+
+public class Mortar extends ShootingMachine implements IAnimatable, IReloading
+{
+    private final AnimationFactory factory = new AnimationFactory(this);
+
+    static AnimationBuilder MOVING_ANIM = new AnimationBuilder().addAnimation("Moving", true);
+
+    public int shootingticks = 0;
+
+    private double wheelspitch = 0.0;
+    private double wheelsspeed = 0.0;
+    private int wheelssoundticks = 10;
+
+    public Mortar(EntityType<? extends MobEntity> entitytype, World level)
+    {
+        super(entitytype, level, MachineType.MORTAR);
+    }
+
+    private <E extends IAnimatable> PlayState wheels_predicate(AnimationEvent<E> event)
+    {
+        event.getController().setAnimation(MOVING_ANIM);
+
+        return PlayState.CONTINUE;
+	}
+
+    @Override
+	public void registerControllers(AnimationData data)
+    {
+        AnimationController<?> wheels_controller = new AnimationController<>(this, "wheels_controller", 1, (t) -> {
+            double d = this.getWheelsSpeed();
+            this.wheelsspeed = d > 0 ? Math.min(d, 1.0) : Math.max(d, -1.0);
+            return wheelspitch += 0.013 * this.wheelsspeed;
+        }, this::wheels_predicate);
+		data.addAnimationController(wheels_controller);
+	}
+
+    @Override
+    public AnimationFactory getFactory()
+    {
+        return this.factory;
+    }
+
+    @Override
+    protected ActionResultType mobInteract(PlayerEntity player, Hand hand)
+    {
+        ItemStack stack = player.getItemInHand(hand);
+
+        if (stack.getItem().equals(Items.FLINT_AND_STEEL))
+        {
+            if (this.useticks <= 0 && this.shootingticks <= 0)
+            {
+                stack.hurtAndBreak(1, player, (p_213833_1_) ->
+                {
+                    p_213833_1_.broadcastBreakEvent(hand);
+                    net.minecraftforge.event.ForgeEventFactory.onPlayerDestroyItem(player, this.useItem, hand);
+                });
+                this.startShooting(player);
+            }
+            return ActionResultType.SUCCESS;
+        }
+        if (stack.getItem().equals(Items.GUNPOWDER))
+        {
+            if (!this.inventory.containsItem(Items.GUNPOWDER))
+            {
+                if (!player.isCreative())
+                {
+                    stack.shrink(1);
+                }
+                this.inventory.putItem(Items.GUNPOWDER);
+            }
+            return ActionResultType.SUCCESS;
+        }
+        if (super.mobInteract(player, hand) == ActionResultType.SUCCESS)
+        {
+            return ActionResultType.SUCCESS;
+        }
+        if (!this.level.isClientSide() && !this.isVehicle())
+        {
+			player.startRiding(this);
+			return ActionResultType.SUCCESS;
+		}
+
+		return ActionResultType.PASS;
+    }
+
+    @Override
+	public void travel(Vector3d pos)
+    {
+		if (this.isAlive())
+        {
+            if (this.isVehicle())
+            {
+			    LivingEntity livingentity = (LivingEntity) this.getControllingPassenger();
+
+                this.setTurretRotationsDest(livingentity.xRot, livingentity.yRot - this.getYaw());
+                this.setYawDest(livingentity.yRot);
+
+                this.updateYaw();
+                this.updateTurretRotations();
+
+				float f0 = livingentity.xxa * 0.2f;
+				float f1 = livingentity.zza;
+				if (f1 <= 0.0f)
+                {
+					f1 *= 0.5f;
+				}
+				this.setSpeed(0.04f);
+
+                pos = new Vector3d(f0, pos.y, f1);
+			}
+            super.travel(pos);
+		}
+	}
+
+    @Override
+    public void tick()
+    {
+        if (this.useticks != 0 && --this.useticks <= 0)
+        {
+            this.useticks = 0;
+            this.delayticks = this.type.specs.delaytime.get();
+        }
+
+        if (this.shootingticks != 0 && --this.shootingticks <= 0)
+        {
+            if (this.inventory.containsItem(Items.GUNPOWDER))
+            {
+                this.useRealise();
+            }
+            else if (!this.level.isClientSide())
+            {
+                Entity passenger = this.getControllingPassenger();
+                if (passenger instanceof PlayerEntity)
+                {
+                    passenger.sendMessage(new TranslationTextComponent(SiegeMachines.ID + ".no_gunpowder").withStyle(TextFormatting.RED), SiegeMachines.CHAT_UUID);
+                }
+            }
+            this.shootingticks = 0;
+        }
+
+        if (!level.isClientSide() && this.isOnGround())
+        {
+            this.setDeltaMovement(this.getWheelsDeltaMovement());
+        }
+
+        if (this.delayticks > 0 && this.isVehicle())
+        {
+            --this.delayticks;
+        }
+
+        if (this.renderupdateticks-- <= 0)
+        {
+            this.updateMachineRender();
+            this.renderupdateticks = SiegeMachines.RENDER_UPDATE_TIME;
+        }
+
+        if (this.getWheelsSpeed() > 0.0081 && this.wheelssoundticks-- <= 0)
+        {
+            this.level.playLocalSound(this.getX(), this.getY(), this.getZ(), SoundTypes.CANNON_WHEELS.get(), SoundCategory.NEUTRAL, 0.3f, 1.0f, true);
+            this.wheelssoundticks = 20;
+        }
+
+        super.tick();
+    }
+
+    @Override
+    public void startShooting(PlayerEntity player)
+    {
+        if (this.delayticks <= 0 && this.useticks <= 0 && this.shootingticks <= 0)
+        {
+            if (!this.level.isClientSide())
+            {
+                this.level.playSound(null, this.getX(), this.getY(), this.getZ(), SoundTypes.FUSE.get(), SoundCategory.BLOCKS, this.getVolumeFromDist(0.5f, 6.0f, this.distanceTo(player)), 0.8f);
+            }
+            this.useticks = this.type.usetime;
+            this.shootingticks = this.type.userealisetime;
+        }
+    }
+
+    @Override
+    public void shoot()
+    {
+        if (!level.isClientSide())
+        {
+            super.shoot();
+            this.setDeltaMovement(this.getDeltaMovement().subtract(this.getShotView().scale(0.25)));
+            this.hasImpulse = true;
+            this.inventory.shrinkItem(Items.GUNPOWDER);
+        }
+        else
+        {
+            this.blowParticles(ParticleTypes.FLAME, 0.035, 25);
+            this.blowParticles(ParticleTypes.CLOUD, 0.2, 60);
+            Vector3d pos = this.position();
+            this.level.playLocalSound(pos.x, pos.y, pos.z, SoundTypes.MORTAR_SHOOTING.get(), SoundCategory.BLOCKS, 1.5f/*this.getVolumeFromDist(1.5f, 64.0f, this.distanceTo(player))*/, 0.85f + this.level.random.nextFloat() * 0.3f, false);
+        }
+    }
+
+    public double getWheelsSpeed()
+    {
+        if (this.isOnGround())
+        {
+            return this.getViewVector(5.0f).multiply(1, 0, 1).dot(this.getDeltaMovement());
+        }
+
+        return 0.0;
+    }
+
+    public Vector3d getWheelsDeltaMovement()
+    {
+        if (this.isOnGround() || this.isInWater())
+        {
+            Vector3d view = this.getViewVector(1.0f);
+            Vector3d movement = this.getDeltaMovement();
+
+            double d0 = movement.x * view.x + movement.z * view.z;
+
+            double d1 = d0 * view.x;
+            double d2 = 0.0;
+            double d3 = d0 * view.z;
+
+            return new Vector3d(d1, d2, d3);
+        }
+
+        return Vector3d.ZERO;
+    }
+
+    @Override
+    @OnlyIn(Dist.CLIENT)
+    public Crosshair createCrosshair()
+    {
+        return new ReloadingCrosshair();
+    }
+
+    @Override
+    public Item getMachineItem()
+    {
+        return ModItems.MORTAR.get();
+    }
+}

src/main/java/magistu/siegemachines/entity/machine/ShootingMachine.java

@@ -0,0 +1,195 @@
+package magistu.siegemachines.entity.machine;
+
+import magistu.siegemachines.SiegeMachines;
+import magistu.siegemachines.entity.IReloading;
+import magistu.siegemachines.entity.projectile.Missile;
+import magistu.siegemachines.entity.projectile.ProjectileBuilder;
+import magistu.siegemachines.network.*;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityType;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.entity.MobEntity;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.entity.projectile.ProjectileEntity;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.particles.IParticleData;
+import net.minecraft.util.ActionResultType;
+import net.minecraft.util.Hand;
+import net.minecraft.util.math.vector.Vector3d;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.util.text.TranslationTextComponent;
+import net.minecraft.world.World;
+
+import java.util.Arrays;
+import java.util.Random;
+
+public abstract class ShootingMachine extends Machine implements IReloading
+{
+    public int shootingticks = 0;
+
+    protected ShootingMachine(EntityType<? extends MobEntity> entitytype, World level, MachineType type)
+    {
+        super(entitytype, level, type);
+    }
+
+    public abstract void startShooting(PlayerEntity player);
+
+    public void shoot()
+    {
+        if (this.type.ammo.length == 0)
+        {
+            return;
+        }
+        ProjectileBuilder projectilebuilder = this.getProjectileBuilder();
+        if (projectilebuilder.equals(ProjectileBuilder.NONE))
+        {
+            Entity passenger = this.getControllingPassenger();
+            if (passenger instanceof PlayerEntity)
+            {
+                passenger.sendMessage(new TranslationTextComponent(SiegeMachines.ID + ".no_ammo").withStyle(TextFormatting.RED), SiegeMachines.CHAT_UUID);
+            }
+            return;
+        }
+        LivingEntity livingentity = (LivingEntity) this.getControllingPassenger();
+        ProjectileEntity projectile = projectilebuilder.factory.create(projectilebuilder.entitytype, this.level, this.getShotPos(), livingentity == null ? this : livingentity, projectilebuilder.projectileitem);
+        if (projectile instanceof Missile)
+        {
+            Missile missile = (Missile) projectile;
+            missile.setItem(new ItemStack(missile.getDefaultItem()));
+        }
+        projectile.shootFromRotation(this, this.getTurretPitch(), this.getGlobalTurretYaw(), 0.0f, this.type.specs.projectilespeed.get(), this.type.specs.inaccuracy.get());
+        this.level.addFreshEntity(projectile);
+        if (!this.level.isClientSide)
+        {
+            int i = this.inventory.shrinkItem(projectilebuilder.item);
+            PacketHandler.sendPacketToAll(
+                    new PacketMachineInventorySlot(this.getId(), i, this.inventory.getItem(i)));
+        }
+    }
+
+    @Override
+    public void use(PlayerEntity player)
+    {
+        if (!this.level.isClientSide)
+        {
+            PacketHandler.sendPacketToAllInArea(new PacketMachineUse(this.getId()), this.blockPosition(), SiegeMachines.RENDER_UPDATE_RANGE_SQR);
+        }
+
+        this.startShooting(player);
+    }
+
+    @Override
+    public void useRealise()
+    {
+        if (!this.level.isClientSide)
+        {
+            PacketHandler.sendPacketToAllInArea(new PacketMachineUseRealise(this.getId()), this.blockPosition(), SiegeMachines.RENDER_UPDATE_RANGE_SQR);
+        }
+
+        this.shoot();
+    }
+
+    @Override
+    protected ActionResultType mobInteract(PlayerEntity player, Hand hand)
+	{
+		ItemStack stack = player.getItemInHand(hand);
+
+		if (this.isValidAmmo(stack))
+		{
+			if (!this.hasAmmo())
+			{
+				if (!player.isCreative())
+				{
+					stack.shrink(1);
+				}
+                this.inventory.putItem(stack.getItem());
+			}
+			return ActionResultType.SUCCESS;
+		}
+		return ActionResultType.PASS;
+	}
+
+    protected Vector3d getShotPos()
+    {
+        double pitch = this.getTurretPitch() * Math.PI / 180.0;
+        double yaw = (this.getViewYRot(0.5f) + this.getTurretYaw()) * Math.PI / 180.0;
+
+        return this.position().add(applyRotations(this.type.turretpivot, 0.0, yaw).add(applyRotations(this.type.turretvector, pitch, yaw)));
+    }
+
+    protected Vector3d getShotView()
+    {
+        double pitch = this.getTurretPitch() * Math.PI / 180.0;
+        double yaw = this.getGlobalTurretYaw() * Math.PI / 180.0;
+
+        double d0 = -Math.sin(yaw) * Math.cos(pitch);
+        double d1 = -Math.sin(pitch);
+        double d2 = Math.cos(yaw) * Math.cos(pitch);
+
+        return new Vector3d(d0, d1, d2).normalize();
+    }
+
+    protected void blowParticles(IParticleData particle, double speed, int amount)
+    {
+        for (int i = 0; i < amount; ++i)
+        {
+            Vector3d pos = this.getShotPos();
+            Vector3d inaccuracy = new Vector3d(new Random().nextGaussian() * 0.2,
+                                               new Random().nextGaussian() * 0.2,
+                                               new Random().nextGaussian() * 0.2);
+            Vector3d velocity = this.getShotView().add(inaccuracy).scale(speed);
+
+            this.level.addParticle(particle, pos.x, pos.y, pos.z, velocity.x, velocity.y, velocity.z);
+        }
+    }
+
+    @Override
+    public void updateMachineRender()
+	{
+        super.updateMachineRender();
+		if (!this.level.isClientSide())
+		{
+            for (int i = 0; i < this.inventory.getContainerSize(); ++i)
+            {
+                if (this.isValidAmmo(this.inventory.getItem(i)))
+                {
+                    PacketHandler.sendPacketToAllInArea(
+                            new PacketMachineInventorySlot(this.getId(), i, this.inventory.getItem(i)),
+                            this.blockPosition(),
+                            SiegeMachines.RENDER_UPDATE_RANGE_SQR);
+                }
+            }
+		}
+	}
+
+    public boolean isValidAmmo(ItemStack stack)
+	{
+		return this.isValidAmmo(stack.getItem());
+	}
+
+    public boolean isValidAmmo(Item entry)
+	{
+		return Arrays.stream(this.type.ammo).anyMatch(builder -> builder.item.equals(entry));
+	}
+
+	public ItemStack getAmmo()
+	{
+		return this.inventory.items.stream().filter(this::isValidAmmo).findFirst().orElse(ItemStack.EMPTY);
+	}
+
+	public boolean hasAmmo()
+	{
+        return this.inventory.items.stream().anyMatch(this::isValidAmmo);
+	}
+
+    public ProjectileBuilder getProjectileBuilder()
+    {
+        ItemStack ammo = this.getAmmo();
+        if (ammo.equals(ItemStack.EMPTY))
+        {
+            return ProjectileBuilder.NONE;
+        }
+        return Arrays.stream(this.type.ammo).filter(builder -> builder.item.equals(ammo.getItem())).findFirst().orElse(ProjectileBuilder.NONE);
+    }
+}

src/main/java/magistu/siegemachines/entity/machine/Trebuchet.java

@@ -0,0 +1,256 @@
+package magistu.siegemachines.entity.machine;
+
+import magistu.siegemachines.SiegeMachines;
+import magistu.siegemachines.client.SoundTypes;
+import magistu.siegemachines.gui.Crosshair;
+import magistu.siegemachines.gui.ReloadingCrosshair;
+import magistu.siegemachines.item.ModItems;
+import net.minecraft.entity.EntityType;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.entity.MobEntity;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ActionResultType;
+import net.minecraft.util.Hand;
+import net.minecraft.util.SoundCategory;
+import net.minecraft.util.math.vector.Vector3d;
+import net.minecraft.world.World;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import software.bernie.geckolib3.core.IAnimatable;
+import software.bernie.geckolib3.core.PlayState;
+import software.bernie.geckolib3.core.builder.AnimationBuilder;
+import software.bernie.geckolib3.core.controller.AnimationController;
+import software.bernie.geckolib3.core.event.predicate.AnimationEvent;
+import software.bernie.geckolib3.core.manager.AnimationData;
+import software.bernie.geckolib3.core.manager.AnimationFactory;
+
+public class Trebuchet extends ShootingMachine implements IAnimatable
+{
+    private final AnimationFactory factory = new AnimationFactory(this);
+
+    static AnimationBuilder SHOOTING_ANIM = new AnimationBuilder().addAnimation("Shooting", true);
+    static AnimationBuilder RELOADING_ANIM = new AnimationBuilder().addAnimation("Reloading", true);
+    static AnimationBuilder IDLE_RELOADED_ANIM = new AnimationBuilder().addAnimation("IdleReloaded", true);
+    static AnimationBuilder IDLE_NOT_RELOADED_ANIM = new AnimationBuilder().addAnimation("IdleNotReloaded", true);
+
+    private final MachinePartEntity[] subentities;
+    private final MachinePartEntity backside;
+
+    private final Vector3d backsidepos;
+
+    public enum State
+    {
+        SHOOTING,
+        RELOADING,
+        IDLE_RELOADED,
+        IDLE_NOT_RELOADED
+    }
+    public State state = State.RELOADING;
+
+    public Trebuchet(EntityType<? extends MobEntity> entitytype, World level)
+    {
+        super(entitytype, level, MachineType.TREBUCHET);
+        this.backside = new MachinePartEntity(this, "backside", 5.0F, 2.0F);
+        this.backsidepos = new Vector3d(0.0, 0.0, -85.0).scale(1.0 / 16.0);
+        this.subentities = new MachinePartEntity[] { this.backside };
+    }
+
+    private <E extends IAnimatable> PlayState predicate(AnimationEvent<E> event)
+    {
+        switch (state)
+        {
+            case SHOOTING:
+                event.getController().setAnimation(SHOOTING_ANIM);
+                return PlayState.CONTINUE;
+            case IDLE_RELOADED:
+                event.getController().setAnimation(IDLE_RELOADED_ANIM);
+                return PlayState.CONTINUE;
+            case RELOADING:
+                event.getController().setAnimation(RELOADING_ANIM);
+                return PlayState.CONTINUE;
+            case IDLE_NOT_RELOADED:
+                event.getController().setAnimation(IDLE_NOT_RELOADED_ANIM);
+                return PlayState.CONTINUE;
+        }
+
+        return PlayState.CONTINUE;
+	}
+
+    private void tickPart(MachinePartEntity subentity, double p_226526_2_, double p_226526_4_, double p_226526_6_)
+    {
+        subentity.setPos(this.getX() + p_226526_2_, this.getY() + p_226526_4_, this.getZ() + p_226526_6_);
+    }
+
+    @Override
+    public void aiStep()
+    {
+        Vector3d[] avector3d = new Vector3d[this.subentities.length];
+
+        Vector3d pos = this.position().add(applyRotations(this.backsidepos, 0.0, this.getYaw()));
+        this.tickPart(this.backside, pos.x, pos.y, pos.z);
+
+        for(int i = 0; i < this.subentities.length; ++i)
+        {
+            avector3d[i] = new Vector3d(this.subentities[i].getX(), this.subentities[i].getY(), this.subentities[i].getZ());
+        }
+
+        for(int i = 0; i < this.subentities.length; ++i)
+        {
+           this.subentities[i].xo = avector3d[i].x;
+           this.subentities[i].yo = avector3d[i].y;
+           this.subentities[i].zo = avector3d[i].z;
+           this.subentities[i].xOld = avector3d[i].x;
+           this.subentities[i].yOld = avector3d[i].y;
+           this.subentities[i].zOld = avector3d[i].z;
+        }
+
+        super.aiStep();
+    }
+
+    public MachinePartEntity[] getSubEntities() {
+      return this.subentities;
+   }
+
+    @Override
+    public net.minecraftforge.entity.PartEntity<?>[] getParts()
+    {
+        return this.subentities;
+    }
+
+    @Override
+	public void registerControllers(AnimationData data)
+    {
+        AnimationController<?> controller = new AnimationController<>(this, "controller", 1, (t) ->
+        {
+            if (this.state.equals(State.RELOADING))
+            {
+                return (double) (this.type.specs.delaytime.get() - this.delayticks) / this.type.specs.delaytime.get();
+            }
+            return t;
+        }, this::predicate);
+		data.addAnimationController(controller);
+	}
+
+    @Override
+    public AnimationFactory getFactory()
+    {
+        return this.factory;
+    }
+
+    @Override
+    protected ActionResultType mobInteract(PlayerEntity player, Hand hand)
+    {
+        ItemStack stack = player.getItemInHand(hand);
+
+        if (super.mobInteract(player, hand) == ActionResultType.SUCCESS)
+        {
+            return ActionResultType.SUCCESS;
+        }
+        if (!this.level.isClientSide() && !this.isVehicle())
+        {
+			player.startRiding(this);
+			return ActionResultType.SUCCESS;
+		}
+
+		return ActionResultType.PASS;
+    }
+
+    public void startShooting(PlayerEntity player)
+    {
+        if (this.delayticks <= 0 && this.useticks <= 0 && this.shootingticks <= 0)
+        {
+            this.state = State.SHOOTING;
+            this.useticks = this.type.usetime;
+            this.shootingticks = this.type.userealisetime;
+
+            Vector3d pos = this.position();
+            this.level.playLocalSound(pos.x, pos.y, pos.z, SoundTypes.TREBUCHET_SHOOTING.get(), SoundCategory.BLOCKS, 1.0f, 1.0f, false);
+        }
+    }
+
+    @Override
+    public void shoot()
+    {
+        if (!level.isClientSide())
+        {
+            super.shoot();
+        }
+    }
+
+    @Override
+	public void travel(Vector3d pos)
+    {
+		if (this.isAlive())
+        {
+            if (this.isVehicle() && this.useticks <= 0 && this.delayticks <= 0)
+            {
+			    LivingEntity livingentity = (LivingEntity) this.getControllingPassenger();
+
+                this.setTurretRotations(livingentity.xRot, this.getTurretYaw());
+                this.updateTurretRotations();
+
+                this.setYawDest(livingentity.yRot);
+                this.updateYaw();
+			}
+            super.travel(pos);
+		}
+	}
+
+    @Override
+    public void tick()
+    {
+        if (this.useticks != 0 && --this.useticks <= 0)
+        {
+            this.state = State.RELOADING;
+            this.useticks = 0;
+            this.delayticks = this.type.specs.delaytime.get();
+        }
+
+        if (this.shootingticks != 0 && --this.shootingticks <= 0)
+        {
+            this.useRealise();
+            this.shootingticks = 0;
+        }
+
+        if (!level.isClientSide() && (this.isOnGround() || this.isInWater()))
+        {
+            this.setDeltaMovement(this.getDeltaMovement().multiply(0.0, 1.0, 0.0));
+        }
+
+        if (this.delayticks > 0 && this.isVehicle())
+        {
+            if (this.delayticks % 40 == 0)
+            {
+                Vector3d pos = this.position();
+                this.level.playLocalSound(pos.x, pos.y, pos.z, SoundTypes.TREBUCHET_RELOADING.get(), SoundCategory.BLOCKS, 1.0f, 1.0f, false);
+            }
+            if (--this.delayticks <= 0)
+            {
+                this.state = State.IDLE_RELOADED;
+            }
+        }
+
+        if (this.renderupdateticks-- <= 0)
+        {
+            this.updateMachineRender();
+            this.renderupdateticks = SiegeMachines.RENDER_UPDATE_TIME;
+        }
+
+        super.tick();
+    }
+
+    @Override
+    @OnlyIn(Dist.CLIENT)
+    public Crosshair createCrosshair()
+    {
+        return new ReloadingCrosshair();
+    }
+
+    @Override
+    public Item getMachineItem()
+    {
+        return ModItems.TREBUCHET.get();
+    }
+}

src/main/java/magistu/siegemachines/entity/projectile/Cannonball.java

@@ -0,0 +1,22 @@
+package magistu.siegemachines.entity.projectile;
+
+import magistu.siegemachines.item.ModItems;
+import net.minecraft.entity.EntityType;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.item.Item;
+import net.minecraft.util.math.vector.Vector3d;
+import net.minecraft.world.World;
+
+public class Cannonball extends Missile
+{
+    public Cannonball(EntityType<Cannonball> type, World level)
+    {
+        super(type, level);
+        this.item = ModItems.CANNONBALL.get();
+    }
+
+	public Cannonball(EntityType<Stone> entitytype, World level, Vector3d pos, LivingEntity entity, Item item)
+    {
+		super(entitytype, level, pos, entity, MissileType.CANNONBALL, item);
+	}
+}

src/main/java/magistu/siegemachines/entity/projectile/FlightType.java

@@ -0,0 +1,8 @@
+package magistu.siegemachines.entity.projectile;
+
+public enum FlightType
+{
+    NONE,
+    AHEAD,
+    SPINNING
+}

src/main/java/magistu/siegemachines/entity/projectile/GiantArrow.java

@@ -0,0 +1,41 @@
+package magistu.siegemachines.entity.projectile;
+
+import magistu.siegemachines.item.ModItems;
+import net.minecraft.entity.*;
+import net.minecraft.entity.projectile.AbstractArrowEntity;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.network.IPacket;
+import net.minecraft.util.math.vector.Vector3d;
+import net.minecraft.world.World;
+import net.minecraftforge.fml.network.NetworkHooks;
+import org.jetbrains.annotations.NotNull;
+
+public class GiantArrow extends AbstractArrowEntity
+{
+    private final IPacket<?> spawningpacket = NetworkHooks.getEntitySpawningPacket(this);
+
+    public GiantArrow(EntityType<GiantArrow> type, World level)
+    {
+        super(type, level);
+    }
+
+	public GiantArrow(EntityType<GiantArrow> entitytype, World level, Vector3d pos, LivingEntity entity, Item item)
+    {
+		super(entitytype, entity, level);
+        this.setPos(pos.x, pos.y, pos.z);
+        this.setBaseDamage(15.0f);
+	}
+
+    @Override
+    protected @NotNull ItemStack getPickupItem()
+    {
+        return new ItemStack(ModItems.GIANT_ARROW.get());
+    }
+
+    @Override
+	public @NotNull IPacket<?> getAddEntityPacket()
+    {
+		return spawningpacket;
+	}
+}

src/main/java/magistu/siegemachines/entity/projectile/GiantStone.java

@@ -0,0 +1,22 @@
+package magistu.siegemachines.entity.projectile;
+
+import magistu.siegemachines.item.ModItems;
+import net.minecraft.entity.EntityType;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.item.Item;
+import net.minecraft.util.math.vector.Vector3d;
+import net.minecraft.world.World;
+
+public class GiantStone extends Missile
+{
+	public GiantStone(EntityType<GiantStone> entitytype, World level)
+    {
+		super(entitytype, level);
+		this.item = ModItems.GIANT_STONE.get();
+	}
+
+	public GiantStone(EntityType<GiantStone> entitytype, World level, Vector3d pos, LivingEntity entity, Item item)
+    {
+		super(entitytype, level, pos, entity, MissileType.GIANT_STONE, item);
+	}
+}

src/main/java/magistu/siegemachines/entity/projectile/IProjectileFactory.java

@@ -0,0 +1,13 @@
+package magistu.siegemachines.entity.projectile;
+
+import net.minecraft.entity.EntityType;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.entity.projectile.ProjectileEntity;
+import net.minecraft.item.Item;
+import net.minecraft.util.math.vector.Vector3d;
+import net.minecraft.world.World;
+
+public interface IProjectileFactory<T extends ProjectileEntity>
+{
+      T create(EntityType<T> entitytype, World level, Vector3d pos, LivingEntity entity, Item item);
+}

src/main/java/magistu/siegemachines/entity/projectile/Missile.java

@@ -0,0 +1,188 @@
+package magistu.siegemachines.entity.projectile;
+
+import magistu.siegemachines.item.ModItems;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.Blocks;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.EntityType;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.entity.ai.attributes.Attributes;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.entity.projectile.ProjectileItemEntity;
+import net.minecraft.item.Item;
+import net.minecraft.particles.BlockParticleData;
+import net.minecraft.network.IPacket;
+import net.minecraft.particles.IParticleData;
+import net.minecraft.util.*;
+import net.minecraft.particles.ParticleTypes;
+import net.minecraft.util.math.*;
+import net.minecraft.util.math.vector.Vector3d;
+import net.minecraft.world.Explosion;
+import net.minecraft.world.ExplosionContext;
+import net.minecraft.world.World;
+import net.minecraftforge.fml.network.NetworkHooks;
+import org.jetbrains.annotations.NotNull;
+
+public abstract class Missile extends ProjectileItemEntity
+{
+	public MissileType type = MissileType.STONE;
+	public Item item = ModItems.STONE.get();
+
+	public Missile(EntityType<? extends Missile> entitytype, World level)
+    {
+		super(entitytype, level);
+	}
+
+	public Missile(EntityType<? extends Missile> entitytype, World level, Vector3d pos, LivingEntity entity, MissileType type, Item item)
+    {
+		super(entitytype, entity, level);
+		this.type = type;
+		this.item = item;
+		this.setPos(pos.x, pos.y, pos.z);
+	}
+
+	@Override
+	public @NotNull Item getDefaultItem()
+	{
+		return this.item;
+	}
+
+	@Override
+	public @NotNull IPacket<?> getAddEntityPacket()
+    {
+		return NetworkHooks.getEntitySpawningPacket(this);
+	}
+
+	@Override
+	public void onHit(RayTraceResult result)
+    {
+		if (result.getType() == RayTraceResult.Type.ENTITY)
+        {
+			EntityRayTraceResult entityRTR = (EntityRayTraceResult)result;
+			Vector3d pos = entityRTR.getLocation();
+			Entity entity = entityRTR.getEntity();
+			float damage = this.type.specs.mass.get() * (float) this.getDeltaMovement().length();
+
+			DamageSource damagesource = DamageSource.thrown(this, this.getOwner());
+			if (this.type.armorpiercing >= 1.0f)
+			{
+				damagesource = damagesource.bypassArmor();
+			}
+			else if (this.type.armorpiercing > 0.0f && entity instanceof LivingEntity)
+			{
+				LivingEntity livingentity = (LivingEntity) entity;
+				damage -= (1.0f - this.type.armorpiercing) * (damage - CombatRules.getDamageAfterAbsorb(damage, (float) livingentity.getArmorValue(), (float) livingentity.getAttributeValue(Attributes.ARMOR_TOUGHNESS)));
+				damagesource = damagesource.bypassArmor();
+			}
+
+			if (!this.level.isClientSide() && this.type.explosive)
+            {
+				this.level.explode(this.getOwner(), pos.x, pos.y, pos.z, 3.0F, Explosion.Mode.NONE);
+				this.remove();
+			}
+
+			entity.hurt(damagesource, damage);
+			Vector3d vector3d = this.getDeltaMovement().multiply(1.0D, 0.0D, 1.0D).normalize().scale((double) this.type.knockback * 0.6D);
+			if (vector3d.lengthSqr() > 0.0D)
+			{
+				entity.push(vector3d.x, 0.1D, vector3d.z);
+			}
+		}
+
+		if (result.getType() == RayTraceResult.Type.BLOCK)
+        {
+			BlockRayTraceResult blockRTR = (BlockRayTraceResult)result;
+			BlockPos blockpos = blockRTR.getBlockPos();
+			BlockState blockstate = this.level.getBlockState(blockpos);
+			boolean smoothimpact = 
+					!this.type.specs.destroysground.get() && (
+					blockstate == Blocks.SAND.defaultBlockState() ||
+					blockstate == Blocks.RED_SAND.defaultBlockState() ||
+					blockstate == Blocks.DIRT.defaultBlockState() ||
+					blockstate == Blocks.GRASS_BLOCK.defaultBlockState() ||
+					blockstate == Blocks.GRASS_PATH.defaultBlockState() ||
+					blockstate == Blocks.COARSE_DIRT.defaultBlockState() ||
+					blockstate == Blocks.SNOW_BLOCK.defaultBlockState()) &&
+					blockRTR.getDirection() == Direction.UP;
+
+			if (blockRTR.getDirection() == Direction.UP)
+            {
+				if (this.type.explosive)
+				{
+					for (int r = 0; r < this.type.specs.explosionpower.get(); ++r)
+					{
+						for (float a = 0; a < 2 * Math.PI; a += Math.PI / 4)
+						{
+							BlockPos pos = blockRTR.getBlockPos().offset(r * MathHelper.cos(a), 0, -r * MathHelper.sin(a));
+							if (this.level.getBlockState(pos) == Blocks.GRASS_BLOCK.defaultBlockState())
+							{
+								this.level.setBlockAndUpdate(pos, Blocks.DIRT.defaultBlockState());
+							}
+						}
+					}
+				}
+				if (!this.level.isClientSide())
+				{
+					this.remove();
+					if (smoothimpact && this.type.explosive)
+					{
+						this.level.explode(this.getOwner(), blockpos.getX(), blockpos.getY(), blockpos.getZ(), this.type.specs.explosionpower.get(), Explosion.Mode.NONE);
+					}
+				}
+				else if (smoothimpact)
+				{
+					this.dustExplosion(new BlockParticleData(ParticleTypes.BLOCK, blockstate).setPos(blockpos), blockpos, this.type.specs.explosionpower.get() / 2, 50);
+				}
+			}
+			if (!this.level.isClientSide() && !smoothimpact && this.type.explosive)
+			{
+				this.level.explode(this.getOwner(), blockpos.getX(), blockpos.getY(), blockpos.getZ(), this.type.specs.explosionpower.get(), Explosion.Mode.BREAK);
+			}
+		}
+
+		if (result.getType() == RayTraceResult.Type.MISS)
+        {
+			this.level.playSound((PlayerEntity)this.getOwner(), this.getOnPos(), SoundEvents.ANVIL_BREAK, SoundCategory.AMBIENT, 1.0f, 1.0f);
+			if(!this.level.isClientSide())
+            {
+				this.remove();
+			}
+		}
+		if (!this.level.isClientSide())
+        {
+			this.remove();
+		}
+	}
+
+	private void dustExplosion(IParticleData particle, BlockPos blockpos, double speed, int amount)
+	{
+		this.dustExplosion(particle, blockpos.getX(), blockpos.getY(), blockpos.getZ(), speed, amount);
+	}
+
+	private void dustExplosion(IParticleData particle, double x, double y, double z, double speed, int amount)
+    {
+        for (int i = 0; i < amount; ++i)
+        {
+			Vector3d movement = this.getDeltaMovement();
+            double d0 = x - 0.05 + this.level.random.nextDouble() * 0.3;
+            double d1 = y + 1.0;
+            double d2 = z - 0.05 + this.level.random.nextDouble() * 0.3;
+            double d3 = movement.x * this.level.random.nextDouble() * speed;
+            double d4 = -movement.y * this.level.random.nextDouble() * speed * 10.0f;
+            double d5 = movement.z * this.level.random.nextDouble() * speed;
+            this.level.addParticle(particle, d0, d1, d2, d3, d4, d5);
+        }
+    }
+
+	@Override
+	public void tick()
+	{
+		if (this.type.flighttype == FlightType.SPINNING)
+		{
+			this.xRot += 0.5;
+			this.setRot(this.yRot, this.xRot);
+		}
+
+		super.tick();
+	}
+}

src/main/java/magistu/siegemachines/entity/projectile/MissileType.java

@@ -0,0 +1,27 @@
+package magistu.siegemachines.entity.projectile;
+
+import magistu.siegemachines.config.MissileSpecs;
+import magistu.siegemachines.config.SpecsConfig;
+
+public enum MissileType
+{
+    CANNONBALL(SpecsConfig.CANNONBALL, 1.5f, true, FlightType.SPINNING, 1.0f),
+    STONE(SpecsConfig.STONE, 1.5f, true, FlightType.SPINNING, 1.0f),
+    GIANT_STONE(SpecsConfig.GIANT_STONE, 3.0f, true, FlightType.SPINNING, 1.0f);
+    //GIANT_ARROW(SpecsConfig.GIANT_ARROW, 1.5f, false, FlightType.AHEAD, 0.5f);
+
+    public final MissileSpecs specs;
+    public final float knockback;
+	public final boolean explosive;
+    public final FlightType flighttype;
+    public final float armorpiercing;
+
+    MissileType(MissileSpecs specs, float knockback, boolean explosive, FlightType headingtype, float armorpiercing)
+    {
+        this.specs = specs;
+        this.knockback = knockback;
+        this.explosive = explosive;
+        this.flighttype = headingtype;
+        this.armorpiercing = armorpiercing;
+    }
+}

src/main/java/magistu/siegemachines/entity/projectile/ProjectileBuilder.java

@@ -0,0 +1,51 @@
+package magistu.siegemachines.entity.projectile;
+
+import magistu.siegemachines.entity.EntityTypes;
+import magistu.siegemachines.item.ModItems;
+import net.minecraft.entity.EntityType;
+import net.minecraft.entity.projectile.ArrowEntity;
+import net.minecraft.entity.projectile.ProjectileEntity;
+import net.minecraft.item.Item;
+import net.minecraft.item.Items;
+
+
+public class ProjectileBuilder<T extends ProjectileEntity>
+{
+    public final static ProjectileBuilder<Stone> NONE = new ProjectileBuilder<>(Items.AIR, EntityTypes.STONE.get(), Stone::new);
+
+    public final static ProjectileBuilder[] NO_AMMO = new ProjectileBuilder[]{};
+    public final static ProjectileBuilder[] CANNON_AMMO = new ProjectileBuilder[]{
+            new ProjectileBuilder(ModItems.CANNONBALL.get(), EntityTypes.CANNONBALL.get(), Cannonball::new)};
+    public final static ProjectileBuilder[] GIANT_THROWING_AMMO = new ProjectileBuilder[]{
+            new ProjectileBuilder(Items.COBBLESTONE, ModItems.GIANT_STONE.get(), EntityTypes.GIANT_STONE.get(), GiantStone::new)};
+    public final static ProjectileBuilder[] THROWING_AMMO = new ProjectileBuilder[]{
+            new ProjectileBuilder(Items.COBBLESTONE, ModItems.STONE.get(), EntityTypes.STONE.get(), Stone::new)};
+    public final static ProjectileBuilder[] BALLISTA_AMMO = new ProjectileBuilder[]{
+            new ProjectileBuilder(ModItems.GIANT_ARROW.get(), EntityTypes.GIANT_ARROW.get(), GiantArrow::new),
+            new ProjectileBuilder(Items.ARROW, EntityType.ARROW, (entitytype, level, pos, entity, item) ->
+            {
+                ArrowEntity arrow = new ArrowEntity(level, entity);
+                arrow.setPos(pos.x, pos.y, pos.z);
+                return arrow;
+            })};
+
+    public final Item item;
+    public final Item projectileitem;
+    public final EntityType<T> entitytype;
+    public final IProjectileFactory<T> factory;
+
+    public ProjectileBuilder(Item item, EntityType<T> entitytype, IProjectileFactory<T> factory)
+    {
+        this(item, item, entitytype, factory);
+    }
+
+    public ProjectileBuilder(Item item, Item projectileitem, EntityType<T> entitytype, IProjectileFactory<T> factory)
+    {
+        this.item = item;
+        this.projectileitem = projectileitem;
+        this.entitytype = entitytype;
+        this.factory = factory;
+    }
+
+
+}

src/main/java/magistu/siegemachines/entity/projectile/Stone.java

@@ -0,0 +1,22 @@
+package magistu.siegemachines.entity.projectile;
+
+import magistu.siegemachines.item.ModItems;
+import net.minecraft.entity.EntityType;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.item.Item;
+import net.minecraft.util.math.vector.Vector3d;
+import net.minecraft.world.World;
+
+public class Stone extends Missile
+{
+	public Stone(EntityType<Stone> entitytype, World level)
+    {
+		super(entitytype, level);
+		this.item = ModItems.STONE.get();
+	}
+
+	public Stone(EntityType<Stone> entitytype, World level, Vector3d pos, LivingEntity entity, Item item)
+    {
+		super(entitytype, level, pos, entity, MissileType.STONE, item);
+	}
+}

src/main/java/magistu/siegemachines/event/ClientEvents.java

@@ -0,0 +1,82 @@
+package magistu.siegemachines.event;
+
+import magistu.siegemachines.client.KeyBindings;
+import magistu.siegemachines.entity.IReloading;
+import magistu.siegemachines.entity.machine.Machine;
+import magistu.siegemachines.gui.Crosshair;
+import magistu.siegemachines.network.PacketHandler;
+import magistu.siegemachines.network.PacketOpenMachineInventory;
+import magistu.siegemachines.network.PacketMachineUse;
+import net.minecraft.client.GameSettings;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.entity.player.ClientPlayerEntity;
+import net.minecraft.client.settings.PointOfView;
+import net.minecraft.entity.Entity;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import net.minecraftforge.client.event.InputEvent;
+import net.minecraftforge.client.event.RenderGameOverlayEvent;
+import net.minecraftforge.eventbus.api.EventPriority;
+import net.minecraftforge.eventbus.api.SubscribeEvent;
+import net.minecraftforge.fml.common.Mod;
+
+
+@Mod.EventBusSubscriber
+public class ClientEvents
+{
+    public static Crosshair crosshair = null;
+
+    @SubscribeEvent(priority = EventPriority.NORMAL, receiveCanceled = true)
+    @OnlyIn(Dist.CLIENT)
+    public static void onKeyPressedEvent(InputEvent.KeyInputEvent ev)
+    {
+        if (KeyBindings.MACHINE_USE.isDown())
+        {
+            ClientPlayerEntity player = Minecraft.getInstance().player;
+            if (player != null && player.isPassenger() && player.getVehicle() instanceof Machine)
+            {
+                PacketHandler.sendToServer(new PacketMachineUse(player.getVehicle().getId()));
+            }
+        }
+
+        if (KeyBindings.MACHINE_INVENTORY.isDown())
+        {
+            ClientPlayerEntity player = Minecraft.getInstance().player;
+            if (player != null && player.isPassenger() && player.getVehicle() instanceof Machine)
+            {
+                PacketHandler.sendToServer(new PacketOpenMachineInventory());
+            }
+        }
+    }
+
+    @SubscribeEvent
+    @OnlyIn(Dist.CLIENT)
+    public static void onRenderOverlayPre(RenderGameOverlayEvent.Pre ev)
+    {
+        if (ev.getType() == RenderGameOverlayEvent.ElementType.CROSSHAIRS)
+        {
+            Minecraft mc = Minecraft.getInstance();
+            GameSettings settings = mc.options;
+            ClientPlayerEntity player = mc.player;
+
+            if ((settings.renderDebug && !settings.hideGui && !player.isReducedDebugInfo() && !settings.reducedDebugInfo) || settings.getCameraType().compareTo(PointOfView.FIRST_PERSON) != 0)
+            {
+                return;
+            }
+
+            if (player.isPassenger())
+            {
+                Entity entity = player.getVehicle();
+                if (entity instanceof IReloading)
+                {
+                    if (crosshair == null)
+                    {
+                        crosshair = ((IReloading) entity).createCrosshair();
+                    }
+                    crosshair.render(ev.getMatrixStack(), ev.getPartialTicks(), mc, player);
+                    ev.setCanceled(true);
+                }
+            }
+        }
+    }
+}

src/main/java/magistu/siegemachines/event/ModEventBusEvents.java

@@ -0,0 +1,23 @@
+package magistu.siegemachines.event;
+
+import magistu.siegemachines.SiegeMachines;
+import magistu.siegemachines.entity.EntityTypes;
+import magistu.siegemachines.entity.machine.*;
+import net.minecraftforge.event.entity.EntityAttributeCreationEvent;
+import net.minecraftforge.eventbus.api.SubscribeEvent;
+import net.minecraftforge.fml.common.Mod;
+
+@Mod.EventBusSubscriber(modid = SiegeMachines.ID, bus = Mod.EventBusSubscriber.Bus.MOD)
+public class ModEventBusEvents
+{
+    @SubscribeEvent
+    public static void addEntityAttributes(EntityAttributeCreationEvent event)
+    {
+        event.put(EntityTypes.MORTAR.get(), Mortar.setEntityAttributes(MachineType.MORTAR).build());
+        event.put(EntityTypes.CULVERIN.get(), Mortar.setEntityAttributes(MachineType.CULVERIN).build());
+        event.put(EntityTypes.TREBUCHET.get(), Trebuchet.setEntityAttributes(MachineType.TREBUCHET).build());
+        event.put(EntityTypes.CATAPULT.get(), Catapult.setEntityAttributes(MachineType.CATAPULT).build());
+        event.put(EntityTypes.BALLISTA.get(), Ballista.setEntityAttributes(MachineType.BALLISTA).build());
+        event.put(EntityTypes.BATTERING_RAM.get(), Ballista.setEntityAttributes(MachineType.BATTERING_RAM).build());
+    }
+}

src/main/java/magistu/siegemachines/gui/AlignmentHelper.java

@@ -0,0 +1,33 @@
+package magistu.siegemachines.gui;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class AlignmentHelper
+{
+    public static final List<String> validAlignmentValues = Arrays.asList(new String[] { "top_left", "top_center", "top_right", "center_left", "center", "center_right", "bottom_left", "bottom_center", "bottom_right" });
+
+    public enum Alignment
+    {
+        TOP_LEFT,
+        TOP_CENTER,
+        TOP_RIGHT,
+        CENTER_LEFT,
+        CENTER,
+        CENTER_RIGHT,
+        BOTTOM_LEFT,
+        BOTTOM_CENTER,
+        BOTTOM_RIGHT;
+
+
+        public static Alignment fromString(String align)
+        {
+            int idx = AlignmentHelper.validAlignmentValues.indexOf(align);
+            if (idx != -1)
+            {
+                return values()[idx];
+            }
+            return CENTER;
+        }
+    }
+}

src/main/java/magistu/siegemachines/gui/ContainerTypes.java

@@ -0,0 +1,22 @@
+package magistu.siegemachines.gui;
+
+import magistu.siegemachines.SiegeMachines;
+import net.minecraft.inventory.container.ContainerType;
+import net.minecraftforge.common.extensions.IForgeContainerType;
+import net.minecraftforge.eventbus.api.IEventBus;
+import net.minecraftforge.fml.RegistryObject;
+import net.minecraftforge.registries.DeferredRegister;
+import net.minecraftforge.registries.ForgeRegistries;
+
+public class ContainerTypes
+{
+    public static final DeferredRegister<ContainerType<?>> CONTAINER_TYPES = DeferredRegister.create(ForgeRegistries.CONTAINERS, SiegeMachines.ID);
+
+    public static final RegistryObject<ContainerType<MachineContainer>> MACHINE_CONTAINER = CONTAINER_TYPES.register("machine", () -> IForgeContainerType.create(MachineContainer::new));
+    public static final RegistryObject<ContainerType<SiegeWorkbenchContainer>> SIEGE_WORKBENCH_CONTAINER = CONTAINER_TYPES.register("siege_workbench", () -> IForgeContainerType.create(SiegeWorkbenchContainer::new));
+
+    public static void register(IEventBus eventBus)
+    {
+        CONTAINER_TYPES.register(eventBus);
+    }
+}

src/main/java/magistu/siegemachines/gui/Crosshair.java

@@ -0,0 +1,26 @@
+package magistu.siegemachines.gui;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+import magistu.siegemachines.SiegeMachines;
+import net.minecraft.client.Minecraft;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+
+@OnlyIn(Dist.CLIENT)
+public abstract class Crosshair extends HudElement
+{
+    protected static final ResourceLocation CROSSHAIR_TEXTURES = new ResourceLocation(SiegeMachines.ID, "textures/gui/crosshairs.png");
+
+    public Crosshair(int width, int height)
+    {
+        super(width, height);
+    }
+
+    public final void render(MatrixStack matrixstack, float partialticks) {}
+
+    public abstract void render(MatrixStack matrixstack, float ticks, Minecraft mc, PlayerEntity player);
+}

src/main/java/magistu/siegemachines/gui/HudElement.java

@@ -0,0 +1,73 @@
+package magistu.siegemachines.gui;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+import net.minecraft.client.Minecraft;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+
+@OnlyIn(Dist.CLIENT)
+public abstract class HudElement
+{
+    protected int width;
+    protected int height;
+
+    public int getAlignedX(AlignmentHelper.Alignment align, int offset)
+    {
+        switch (align)
+        {
+            case TOP_LEFT:
+            case CENTER_LEFT:
+            case BOTTOM_LEFT:
+                return 5 + offset;
+            case TOP_CENTER:
+            case CENTER:
+            case BOTTOM_CENTER:
+                return Minecraft.getInstance().getWindow().getGuiScaledWidth() / 2 - this.width / 2 + offset;
+            case TOP_RIGHT:
+            case CENTER_RIGHT:
+            case BOTTOM_RIGHT:
+                return Minecraft.getInstance().getWindow().getGuiScaledWidth() - this.width - 5 + offset;
+        }
+        return 0;
+    }
+
+    public int getAlignedY(AlignmentHelper.Alignment align, int offset)
+    {
+        switch (align)
+        {
+            case TOP_LEFT:
+            case TOP_CENTER:
+            case TOP_RIGHT:
+                return 5 + offset;
+            case CENTER_LEFT:
+            case CENTER:
+            case CENTER_RIGHT:
+                return Minecraft.getInstance().getWindow().getGuiScaledHeight() / 2 - this.height / 2 + 16 + offset;
+            case BOTTOM_CENTER:
+                return Minecraft.getInstance().getWindow().getGuiScaledHeight() - this.height - 65 + offset;
+            case BOTTOM_LEFT:
+            case BOTTOM_RIGHT:
+                return Minecraft.getInstance().getWindow().getGuiScaledHeight() - this.height - 5 + offset;
+        }
+        return 0;
+    }
+
+    public HudElement(int elementWidth, int elementHeight)
+    {
+        this.width = elementWidth;
+        this.height = elementHeight;
+    }
+
+    public int getWidth()
+    {
+        return this.width;
+    }
+
+    public int getHeight()
+    {
+        return this.height;
+    }
+
+    public abstract void render(MatrixStack paramMatrixStack, float paramFloat);
+}

src/main/java/magistu/siegemachines/gui/MachineContainer.java

@@ -0,0 +1,137 @@
+package magistu.siegemachines.gui;
+
+import magistu.siegemachines.entity.machine.Machine;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.entity.player.PlayerInventory;
+import net.minecraft.inventory.container.Container;
+import net.minecraft.inventory.container.Slot;
+import net.minecraft.item.ItemStack;
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.world.World;
+import net.minecraftforge.items.IItemHandler;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+
+public class MachineContainer extends Container
+{
+	private final int containersize;
+	private final Machine machine;
+
+	public MachineContainer(final int id, final PlayerInventory inv, final Machine machine)
+    {
+		super(ContainerTypes.MACHINE_CONTAINER.get(), id);
+		this.containersize = machine.inventory.getContainerSize();
+		this.machine = machine;
+
+		for (int row = 0; row < 3; row++)
+		{
+			for (int col = 0; col < 9; col++)
+			{
+				this.addSlot(new Slot(inv, col + row * 9 + 9, 8 + col * 18, 166 - (4 - row) * 18 - 10));
+			}
+		}
+
+		for (int col = 0; col < 9; col++)
+		{
+			this.addSlot(new Slot(inv, col, 8 + col * 18, 142));
+		}
+
+		int n = 0;
+		int col_size = (int) Math.ceil((double)this.containersize / 9);
+		for (int row = 0; row < col_size; row++)
+		{
+			for (int col = 0; col < 9 && n < this.containersize; col++)
+			{
+				this.addSlot(new Slot(machine.inventory, col + row * 9, 8 + col * 18, 18 + row * 18));
+				n++;
+			}
+		}
+	}
+
+	public MachineContainer(final int id, final PlayerInventory inv, final PacketBuffer data)
+    {
+		this(id, inv, getMachine(inv));
+	}
+
+	private static Machine getMachine(final PlayerInventory inv)
+	{
+		Objects.requireNonNull(inv, "Player Inventory Cannot Be Null.");
+		PlayerEntity player = inv.player;
+		Entity entity;
+		if (player.isPassenger())
+		{
+			entity = player.getVehicle();
+			if (entity instanceof Machine)
+			{
+				return (Machine) player.getVehicle();
+			}
+		}
+
+		throw new IllegalStateException("Entity Is Not Correct.");
+	}
+
+	@Override
+	public boolean stillValid(PlayerEntity player)
+	{
+		return machine.inventory.stillValid(player);
+	}
+
+	@Override
+	public @NotNull ItemStack quickMoveStack(@NotNull PlayerEntity player, int index)
+    {
+		ItemStack itemstack = ItemStack.EMPTY;
+		Slot slot = this.slots.get(index);
+		if (slot != null && slot.hasItem())
+		{
+			ItemStack itemstack1 = slot.getItem();
+			itemstack = itemstack1.copy();
+			if (index < 9)
+			{
+				if (!this.moveItemStackTo(itemstack1, 9, this.slots.size(), true))
+				{
+					return ItemStack.EMPTY;
+				}
+				slot.onQuickCraft(itemstack1, itemstack);
+			}
+			else if (!this.moveItemStackTo(itemstack1, 0, 9, false))
+			{
+				if (index < 9 + 27)
+				{
+					if (!this.moveItemStackTo(itemstack1, 9 + 27, this.slots.size(), true))
+					{
+						return ItemStack.EMPTY;
+					}
+				}
+				else
+				{
+					if (!this.moveItemStackTo(itemstack1, 9, 9 + 27, false))
+					{
+						return ItemStack.EMPTY;
+					}
+				}
+				return ItemStack.EMPTY;
+			}
+			if (itemstack1.getCount() == 0)
+			{
+				slot.set(ItemStack.EMPTY);
+			}
+			else
+			{
+				slot.setChanged();
+			}
+			if (itemstack1.getCount() == itemstack.getCount())
+			{
+				return ItemStack.EMPTY;
+			}
+			slot.onTake(player, itemstack1);
+		}
+		return itemstack;
+	}
+
+	public int getContainerSize() 
+	{
+		return this.containersize;
+	}
+}

src/main/java/magistu/siegemachines/gui/MachineInventoryScreen.java

@@ -0,0 +1,81 @@
+package magistu.siegemachines.gui;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+import com.mojang.blaze3d.systems.RenderSystem;
+import magistu.siegemachines.SiegeMachines;
+import net.minecraft.client.gui.screen.inventory.ContainerScreen;
+import net.minecraft.entity.player.PlayerInventory;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import net.minecraftforge.api.distmarker.Dist;
+import org.jetbrains.annotations.NotNull;
+
+@OnlyIn(Dist.CLIENT)
+public class MachineInventoryScreen extends ContainerScreen<MachineContainer>
+{
+	private final ResourceLocation displaceCaseGui;
+
+	public MachineInventoryScreen(MachineContainer container, PlayerInventory inv, ITextComponent titleIn)
+    {
+		super(container, inv, titleIn);
+
+		this.leftPos = 0;
+		this.topPos = 0;
+		this.imageWidth = 176;
+		this.imageHeight = 166;
+		switch (container.getContainerSize()) 
+		{
+			case 18:
+				this.displaceCaseGui = new ResourceLocation(SiegeMachines.ID, "textures/gui/machine_inventory_2.png");
+				break;
+			case 27:
+				this.displaceCaseGui = new ResourceLocation(SiegeMachines.ID, "textures/gui/machine_inventory_3.png");
+				break; 
+			default:
+				this.displaceCaseGui = new ResourceLocation(SiegeMachines.ID, "textures/gui/machine_inventory_1.png");
+				break;
+		}
+	}
+
+	@Override
+	public void render(MatrixStack matrixStack, int mouseX, int mouseY, float partialTicks)
+    {
+		this.renderBackground(matrixStack);
+		super.render(matrixStack, mouseX, mouseY, partialTicks);
+		this.renderTooltip(matrixStack, mouseX, mouseY);
+	}
+
+    @Override
+	protected void renderTooltip(@NotNull MatrixStack matrixStack, int x, int y)
+    {
+		if (this.minecraft.player.inventory.getCarried().isEmpty() && this.hoveredSlot != null && this.hoveredSlot.hasItem())
+		{
+    		this.renderTooltip(matrixStack, this.hoveredSlot.getItem(), x, y);
+		}
+	}
+
+	@SuppressWarnings("deprecation")
+	@Override
+	protected void renderBg(@NotNull MatrixStack matrixStack, float partialTicks, int mouseX, int mouseY)
+    {
+		RenderSystem.color4f(1f, 1f, 1f, 1f);
+		assert this.minecraft != null;
+		this.minecraft.textureManager.bind(this.displaceCaseGui);
+		int x = (this.width - this.imageWidth) / 2;
+		int y = (this.height - this.imageHeight) / 2;
+		this.blit(matrixStack, x, y, 0, 0, this.imageWidth, this.imageHeight);
+	}
+
+	@Override
+	public boolean keyPressed(int key, int b, int c)
+	{
+		assert this.minecraft != null;
+		if (key == 256)
+		{
+			this.minecraft.player.closeContainer();
+			return true;
+		}
+		return super.keyPressed(key, b, c);
+	}
+}

src/main/java/magistu/siegemachines/gui/ReloadingCrosshair.java

@@ -0,0 +1,67 @@
+package magistu.siegemachines.gui;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+import com.mojang.blaze3d.systems.RenderSystem;
+import magistu.siegemachines.entity.machine.Machine;
+import net.minecraft.client.Minecraft;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+
+@OnlyIn(Dist.CLIENT)
+public class ReloadingCrosshair extends Crosshair
+{
+    //public static ResourceLocation TYPE = new ResourceLocation(SiegeMachines.ID, "siege_machine");
+    public int x;
+    public int y;
+
+    public ReloadingCrosshair()
+    {
+        super(9, 9);
+        this.x = Minecraft.getInstance().getWindow().getGuiScaledWidth() / 2;
+        this.y = Minecraft.getInstance().getWindow().getGuiScaledHeight() / 2;
+    }
+
+    public void render(MatrixStack matrixstack, float ticks, Minecraft mc, PlayerEntity player)
+    {
+        RenderSystem.assertThread(RenderSystem::isOnRenderThread);
+
+        if (!player.isPassenger())
+        {
+            return;
+        }
+        Entity entity = player.getVehicle();
+
+        if (entity instanceof Machine)
+        {
+            Machine machine = (Machine) entity;
+
+            int width = 11;
+            int height = 11;
+            int imagex = 0;
+            int imagey = 0;
+            int originx = (mc.getWindow().getGuiScaledWidth() - width) / 2;
+            int originy = (mc.getWindow().getGuiScaledHeight() - height) / 2;
+            int animationsize = 23;
+            if (machine.useticks > 0)
+            {
+                imagey = height;
+            }
+            else if (machine.delayticks > 0)
+            {
+                int number = (int) (((double) animationsize) * ((double) (machine.type.specs.delaytime.get() - machine.delayticks) / (double) machine.type.specs.delaytime.get()));
+                imagex = width;
+                imagey = height * number;
+            }
+
+            RenderSystem.pushMatrix();
+
+            mc.getTextureManager().bind(CROSSHAIR_TEXTURES);
+
+            mc.gui.blit(matrixstack, originx, originy, imagex, imagey, width, height);
+
+            RenderSystem.popMatrix();
+        }
+    }
+}

src/main/java/magistu/siegemachines/gui/SiegeWorkbenchContainer.java

@@ -0,0 +1,615 @@
+package magistu.siegemachines.gui;
+
+import com.google.common.collect.Sets;
+import magistu.siegemachines.block.ModBlocks;
+import magistu.siegemachines.data.recipes.ModRecipes;
+import magistu.siegemachines.data.recipes.SiegeWorkbenchRecipe;
+import net.minecraft.crash.CrashReport;
+import net.minecraft.crash.CrashReportCategory;
+import net.minecraft.crash.ReportedException;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.entity.player.PlayerInventory;
+import net.minecraft.entity.player.ServerPlayerEntity;
+import net.minecraft.inventory.CraftResultInventory;
+import net.minecraft.inventory.CraftingInventory;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.inventory.container.*;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.crafting.IRecipe;
+import net.minecraft.item.crafting.IRecipeType;
+import net.minecraft.network.PacketBuffer;
+import net.minecraft.network.play.server.SSetSlotPacket;
+import net.minecraft.util.IWorldPosCallable;
+import net.minecraft.util.NonNullList;
+import net.minecraft.util.Util;
+import net.minecraft.world.World;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Optional;
+import java.util.Set;
+
+public class SiegeWorkbenchContainer extends Container
+{
+    private final CraftingInventory craftSlots = new CraftingInventory(this, 3, 3);
+    private final CraftResultInventory resultSlots = new CraftResultInventory();
+    private final IWorldPosCallable access;
+    private final PlayerEntity player;
+
+    private int quickcraftType = -1;
+    private int quickcraftStatus;
+    private final Set<Slot> quickcraftSlots = Sets.newHashSet();
+
+    public SiegeWorkbenchContainer(int p_i50089_1_, PlayerInventory p_i50089_2_, PacketBuffer buffer)
+    {
+        this(p_i50089_1_, p_i50089_2_, IWorldPosCallable.NULL);
+    }
+
+    public SiegeWorkbenchContainer(int p_i50090_1_, PlayerInventory p_i50090_2_, IWorldPosCallable p_i50090_3_)
+    {
+        super(ContainerTypes.SIEGE_WORKBENCH_CONTAINER.get(), p_i50090_1_);
+        this.access = p_i50090_3_;
+        this.player = p_i50090_2_.player;
+        this.addSlot(new CraftingResultSlot(p_i50090_2_.player, this.craftSlots, this.resultSlots, 0, 124, 35));
+
+        for (int i = 0; i < 3; ++i)
+        {
+            for (int j = 0; j < 3; ++j)
+            {
+                this.addSlot(new Slot(this.craftSlots, j + i * 3, 30 + j * 18, 17 + i * 18));
+            }
+        }
+
+        for (int k = 0; k < 3; ++k)
+        {
+            for (int i1 = 0; i1 < 9; ++i1)
+            {
+                this.addSlot(new Slot(p_i50090_2_, i1 + k * 9 + 9, 8 + i1 * 18, 84 + k * 18));
+            }
+        }
+
+        for (int l = 0; l < 9; ++l)
+        {
+            this.addSlot(new Slot(p_i50090_2_, l, 8 + l * 18, 142));
+        }
+
+    }
+
+    // to create resulting item
+    protected static void slotChangedCraftingGrid(int p_217066_0_, World p_217066_1_, PlayerEntity p_217066_2_, CraftingInventory p_217066_3_, CraftResultInventory p_217066_4_)
+    {
+        if (!p_217066_1_.isClientSide)
+        {
+            ServerPlayerEntity serverplayerentity = (ServerPlayerEntity) p_217066_2_;
+            ItemStack itemstack = ItemStack.EMPTY;
+            Optional<SiegeWorkbenchRecipe> optional = p_217066_1_.getServer().getRecipeManager().getRecipeFor(ModRecipes.SIEGE_WORKBENCH_RECIPE, p_217066_3_, p_217066_1_);
+            if (optional.isPresent())
+            {
+                SiegeWorkbenchRecipe icraftingrecipe = optional.get();
+                if (p_217066_4_.setRecipeUsed(p_217066_1_, serverplayerentity, icraftingrecipe))
+                {
+                    itemstack = icraftingrecipe.assemble(p_217066_3_);
+                }
+            }
+
+            p_217066_4_.setItem(0, itemstack);
+            serverplayerentity.connection.send(new SSetSlotPacket(p_217066_0_, 0, itemstack));
+        }
+    }
+
+    @Override
+    public void slotsChanged(@NotNull IInventory p_75130_1_)
+    {
+        this.access.execute((p_217069_1_, p_217069_2_) -> slotChangedCraftingGrid(this.containerId, p_217069_1_, this.player, this.craftSlots, this.resultSlots));
+    }
+
+    @Override
+    public void removed(@NotNull PlayerEntity p_75134_1_)
+    {
+        super.removed(p_75134_1_);
+        this.access.execute((p_217068_2_, p_217068_3_) -> this.clearContainer(p_75134_1_, p_217068_2_, this.craftSlots));
+    }
+
+    @Override
+    public boolean stillValid(PlayerEntity p_75145_1_)
+    {
+        return stillValid(this.access, p_75145_1_, ModBlocks.SIEGE_WORKBENCH.get());
+    }
+
+
+    public ItemStack onTakeFromSlot(Slot slot, PlayerEntity p_190901_1_, ItemStack p_190901_2_)
+    {
+        if (slot instanceof CraftingResultSlot)
+        {
+            return this.onCraft(p_190901_1_, p_190901_2_);
+        }
+        return slot.onTake(p_190901_1_, p_190901_2_);
+    }
+
+    public <C extends IInventory, T extends IRecipe<C>> NonNullList<ItemStack> getRemainingItemsFor(IRecipeType<T> p_215369_1_, C p_215369_2_, World p_215369_3_)
+    {
+        Optional<T> optional = p_215369_3_.getRecipeManager().getRecipeFor(p_215369_1_, p_215369_2_, p_215369_3_);
+        if (optional.isPresent())
+        {
+            return optional.get().getRemainingItems(p_215369_2_);
+        }
+        else
+        {
+            NonNullList<ItemStack> nonnulllist = NonNullList.withSize(p_215369_2_.getContainerSize(), ItemStack.EMPTY);
+            for (int i = 0; i < nonnulllist.size(); ++i)
+            {
+                nonnulllist.set(i, p_215369_2_.getItem(i));
+            }
+
+            return nonnulllist;
+        }
+    }
+
+    public ItemStack onCraft(PlayerEntity p_190901_1_, ItemStack p_190901_2_)
+    {
+        //slot.checkTakeAchievements(p_190901_2_);
+        net.minecraftforge.common.ForgeHooks.setCraftingPlayer(p_190901_1_);
+        NonNullList<ItemStack> nonnulllist = this.getRemainingItemsFor(IRecipeType.CRAFTING, this.craftSlots, p_190901_1_.level);
+        net.minecraftforge.common.ForgeHooks.setCraftingPlayer(null);
+        for(int i = 0; i < nonnulllist.size(); ++i)
+        {
+            ItemStack itemstack = this.craftSlots.getItem(i);
+            ItemStack itemstack1 = nonnulllist.get(i);
+            if (!itemstack.isEmpty())
+            {
+                this.craftSlots.removeItem(i, 64);
+                itemstack = this.craftSlots.getItem(i);
+            }
+
+            if (!itemstack1.isEmpty())
+            {
+                if (itemstack.isEmpty())
+                {
+                    this.craftSlots.setItem(i, itemstack1);
+                }
+                else if (ItemStack.isSame(itemstack, itemstack1) && ItemStack.tagMatches(itemstack, itemstack1))
+                {
+                    itemstack1.grow(itemstack.getCount());
+                    this.craftSlots.setItem(i, itemstack1);
+                }
+                else if (!this.player.inventory.add(itemstack1))
+                {
+                    this.player.drop(itemstack1, false);
+                }
+            }
+        }
+
+        return p_190901_2_;
+    }
+
+    @Override
+    public @NotNull ItemStack quickMoveStack(PlayerEntity p_82846_1_, int p_82846_2_)
+    {
+        ItemStack itemstack = ItemStack.EMPTY;
+        Slot slot = this.slots.get(p_82846_2_);
+        if (slot != null && slot.hasItem())
+        {
+            ItemStack itemstack1 = slot.getItem();
+            itemstack = itemstack1.copy();
+            if (p_82846_2_ == 0)
+            {
+                this.access.execute((p_217067_2_, p_217067_3_) -> itemstack1.getItem().onCraftedBy(itemstack1, p_217067_2_, p_82846_1_));
+                if (!this.moveItemStackTo(itemstack1, 10, 46, true))
+                {
+                    return ItemStack.EMPTY;
+                }
+
+                slot.onQuickCraft(itemstack1, itemstack);
+            }
+            else if (p_82846_2_ >= 10 && p_82846_2_ < 46)
+            {
+                if (!this.moveItemStackTo(itemstack1, 1, 10, false))
+                {
+                    if (p_82846_2_ < 37)
+                    {
+                        if (!this.moveItemStackTo(itemstack1, 37, 46, false))
+                        {
+                            return ItemStack.EMPTY;
+                        }
+                    }
+                    else if (!this.moveItemStackTo(itemstack1, 10, 37, false))
+                    {
+                        return ItemStack.EMPTY;
+                    }
+                }
+            }
+            else if (!this.moveItemStackTo(itemstack1, 10, 46, false))
+            {
+                return ItemStack.EMPTY;
+            }
+
+            if (itemstack1.isEmpty())
+            {
+                slot.set(ItemStack.EMPTY);
+            }
+            else
+            {
+                slot.setChanged();
+            }
+
+            if (itemstack1.getCount() == itemstack.getCount())
+            {
+                return ItemStack.EMPTY;
+            }
+
+            ItemStack itemstack2 = onTakeFromSlot(slot, p_82846_1_, itemstack1);
+            if (p_82846_2_ == 0)
+            {
+                p_82846_1_.drop(itemstack2, false);
+            }
+        }
+
+        return itemstack;
+    }
+
+    public boolean canTakeItemForPickAll(ItemStack p_94530_1_, Slot p_94530_2_)
+    {
+        return p_94530_2_.container != this.resultSlots && super.canTakeItemForPickAll(p_94530_1_, p_94530_2_);
+    }
+
+    @OnlyIn(Dist.CLIENT)
+    public int getSize()
+    {
+        return 10;
+    }
+
+    @Override
+    public @NotNull ItemStack clicked(int p_184996_1_, int p_184996_2_, ClickType p_184996_3_, PlayerEntity p_184996_4_)
+    {
+        try
+        {
+            ItemStack result = this.doClick(p_184996_1_, p_184996_2_, p_184996_3_, p_184996_4_);
+            this.slotsChanged(this.craftSlots);
+            this.slotsChanged(this.resultSlots);
+            return result;
+        }
+        catch (Exception exception)
+        {
+            CrashReport crashreport = CrashReport.forThrowable(exception, "Container click");
+            CrashReportCategory crashreportcategory = crashreport.addCategory("Click info");
+            crashreportcategory.setDetail("Menu Class", () -> this.getClass().getCanonicalName());
+            crashreportcategory.setDetail("Slot Count", this.slots.size());
+            crashreportcategory.setDetail("Slot", p_184996_1_);
+            crashreportcategory.setDetail("Button", p_184996_2_);
+            crashreportcategory.setDetail("Type", p_184996_3_);
+            throw new ReportedException(crashreport);
+        }
+    }
+
+    @Override
+    protected void resetQuickCraft()
+    {
+        this.quickcraftStatus = 0;
+        this.quickcraftSlots.clear();
+    }
+
+    private ItemStack doClick(int index1, int index2, ClickType clicktype, PlayerEntity player)
+    {
+        ItemStack itemstack = ItemStack.EMPTY;
+        PlayerInventory playerinventory = player.inventory;
+        if (clicktype == ClickType.QUICK_CRAFT)
+        {
+           int i1 = this.quickcraftStatus;
+           this.quickcraftStatus = getQuickcraftHeader(index2);
+           if ((i1 != 1 || this.quickcraftStatus != 2) && i1 != this.quickcraftStatus)
+           {
+              this.resetQuickCraft();
+           }
+           else if (playerinventory.getCarried().isEmpty())
+           {
+              this.resetQuickCraft();
+           }
+           else if (this.quickcraftStatus == 0)
+           {
+              this.quickcraftType = getQuickcraftType(index2);
+              if (isValidQuickcraftType(this.quickcraftType, player))
+              {
+                 this.quickcraftStatus = 1;
+                 this.quickcraftSlots.clear();
+              }
+              else
+              {
+                 this.resetQuickCraft();
+              }
+           }
+           else if (this.quickcraftStatus == 1)
+           {
+              Slot slot7 = this.slots.get(index1);
+              ItemStack itemstack12 = playerinventory.getCarried();
+              if (slot7 != null && canItemQuickReplace(slot7, itemstack12, true) && slot7.mayPlace(itemstack12) && (this.quickcraftType == 2 || itemstack12.getCount() > this.quickcraftSlots.size()) && this.canDragTo(slot7))
+              {
+                 this.quickcraftSlots.add(slot7);
+              }
+           }
+           else if (this.quickcraftStatus == 2)
+           {
+              if (!this.quickcraftSlots.isEmpty())
+              {
+                 ItemStack itemstack10 = playerinventory.getCarried().copy();
+                 int k1 = playerinventory.getCarried().getCount();
+
+                 for(Slot slot8 : this.quickcraftSlots)
+                 {
+                    ItemStack itemstack13 = playerinventory.getCarried();
+                    if (slot8 != null && canItemQuickReplace(slot8, itemstack13, true) && slot8.mayPlace(itemstack13) && (this.quickcraftType == 2 || itemstack13.getCount() >= this.quickcraftSlots.size()) && this.canDragTo(slot8))
+                    {
+                       ItemStack itemstack14 = itemstack10.copy();
+                       int j3 = slot8.hasItem() ? slot8.getItem().getCount() : 0;
+                       getQuickCraftSlotCount(this.quickcraftSlots, this.quickcraftType, itemstack14, j3);
+                       int k3 = Math.min(itemstack14.getMaxStackSize(), slot8.getMaxStackSize(itemstack14));
+                       if (itemstack14.getCount() > k3)
+                       {
+                          itemstack14.setCount(k3);
+                       }
+
+                       k1 -= itemstack14.getCount() - j3;
+                       slot8.set(itemstack14);
+                    }
+                 }
+
+                 itemstack10.setCount(k1);
+                 playerinventory.setCarried(itemstack10);
+              }
+
+              this.resetQuickCraft();
+           }
+           else
+           {
+              this.resetQuickCraft();
+           }
+        }
+        else if (this.quickcraftStatus != 0)
+        {
+           this.resetQuickCraft();
+        }
+        else if ((clicktype == ClickType.PICKUP || clicktype == ClickType.QUICK_MOVE) && (index2 == 0 || index2 == 1))
+        {
+           if (index1 == -999)
+           {
+              if (!playerinventory.getCarried().isEmpty())
+              {
+                 if (index2 == 0)
+                 {
+                    player.drop(playerinventory.getCarried(), true);
+                    playerinventory.setCarried(ItemStack.EMPTY);
+                 }
+
+                 if (index2 == 1)
+                 {
+                    player.drop(playerinventory.getCarried().split(1), true);
+                 }
+              }
+           }
+           else if (clicktype == ClickType.QUICK_MOVE)
+           {
+              if (index1 < 0)
+              {
+                 return ItemStack.EMPTY;
+              }
+
+              Slot slot5 = this.slots.get(index1);
+              if (slot5 == null || !slot5.mayPickup(player))
+              {
+                 return ItemStack.EMPTY;
+              }
+
+              for(ItemStack itemstack8 = this.quickMoveStack(player, index1); !itemstack8.isEmpty() && ItemStack.isSame(slot5.getItem(), itemstack8); itemstack8 = this.quickMoveStack(player, index1))
+              {
+                 itemstack = itemstack8.copy();
+              }
+           }
+           else
+           {
+              if (index1 < 0)
+              {
+                 return ItemStack.EMPTY;
+              }
+
+              Slot slot6 = this.slots.get(index1);
+              if (slot6 != null)
+              {
+                 ItemStack itemstack9 = slot6.getItem();
+                 ItemStack itemstack11 = playerinventory.getCarried();
+                 if (!itemstack9.isEmpty())
+                 {
+                    itemstack = itemstack9.copy();
+                 }
+
+                 if (itemstack9.isEmpty())
+                 {
+                    if (!itemstack11.isEmpty() && slot6.mayPlace(itemstack11))
+                    {
+                       int j2 = index2 == 0 ? itemstack11.getCount() : 1;
+                       if (j2 > slot6.getMaxStackSize(itemstack11))
+                       {
+                          j2 = slot6.getMaxStackSize(itemstack11);
+                       }
+
+                       slot6.set(itemstack11.split(j2));
+                    }
+                 }
+                 else if (slot6.mayPickup(player))
+                 {
+                    if (itemstack11.isEmpty())
+                    {
+                       if (itemstack9.isEmpty())
+                       {
+                          slot6.set(ItemStack.EMPTY);
+                          playerinventory.setCarried(ItemStack.EMPTY);
+                       }
+                       else
+                       {
+                          int k2 = index2 == 0 ? itemstack9.getCount() : (itemstack9.getCount() + 1) / 2;
+                          playerinventory.setCarried(slot6.remove(k2));
+                          if (itemstack9.isEmpty())
+                          {
+                             slot6.set(ItemStack.EMPTY);
+                          }
+
+                          onTakeFromSlot(slot6, player, playerinventory.getCarried());
+                       }
+                    }
+                    else if (slot6.mayPlace(itemstack11))
+                    {
+                       if (consideredTheSameItem(itemstack9, itemstack11))
+                       {
+                          int l2 = index2 == 0 ? itemstack11.getCount() : 1;
+                          if (l2 > slot6.getMaxStackSize(itemstack11) - itemstack9.getCount())
+                          {
+                             l2 = slot6.getMaxStackSize(itemstack11) - itemstack9.getCount();
+                          }
+
+                          if (l2 > itemstack11.getMaxStackSize() - itemstack9.getCount())
+                          {
+                             l2 = itemstack11.getMaxStackSize() - itemstack9.getCount();
+                          }
+                          itemstack11.shrink(l2);
+                          itemstack9.grow(l2);
+                       }
+                       else if (itemstack11.getCount() <= slot6.getMaxStackSize(itemstack11))
+                       {
+                          slot6.set(itemstack11);
+                          playerinventory.setCarried(itemstack9);
+                       }
+                    }
+                    else if (itemstack11.getMaxStackSize() > 1 && consideredTheSameItem(itemstack9, itemstack11) && !itemstack9.isEmpty())
+                    {
+                       int i3 = itemstack9.getCount();
+                       if (i3 + itemstack11.getCount() <= itemstack11.getMaxStackSize())
+                       {
+                          itemstack11.grow(i3);
+                          itemstack9 = slot6.remove(i3);
+                          if (itemstack9.isEmpty())
+                          {
+                             slot6.set(ItemStack.EMPTY);
+                          }
+
+                          onTakeFromSlot(slot6, player, playerinventory.getCarried());
+                       }
+                    }
+                 }
+
+                 slot6.setChanged();
+              }
+           }
+        }
+        else if (clicktype == ClickType.SWAP)
+        {
+           Slot slot = this.slots.get(index1);
+           ItemStack itemstack1 = playerinventory.getItem(index2);
+           ItemStack itemstack2 = slot.getItem();
+           if (!itemstack1.isEmpty() || !itemstack2.isEmpty())
+           {
+              if (itemstack1.isEmpty())
+              {
+                 if (slot.mayPickup(player))
+                 {
+                    playerinventory.setItem(index2, itemstack2);
+                    //slot.onSwapCraft(itemstack2.getCount());
+                    slot.set(ItemStack.EMPTY);
+                    onTakeFromSlot(slot, player, itemstack2);
+                 }
+              }
+              else if (itemstack2.isEmpty())
+              {
+                 if (slot.mayPlace(itemstack1))
+                 {
+                    int i = slot.getMaxStackSize(itemstack1);
+                    if (itemstack1.getCount() > i)
+                    {
+                       slot.set(itemstack1.split(i));
+                    }
+                    else
+                    {
+                       slot.set(itemstack1);
+                       playerinventory.setItem(index2, ItemStack.EMPTY);
+                    }
+                 }
+              }
+              else if (slot.mayPickup(player) && slot.mayPlace(itemstack1))
+              {
+                 int l1 = slot.getMaxStackSize(itemstack1);
+                 if (itemstack1.getCount() > l1)
+                 {
+                    slot.set(itemstack1.split(l1));
+                    onTakeFromSlot(slot, player, itemstack2);
+                    if (!playerinventory.add(itemstack2))
+                    {
+                       player.drop(itemstack2, true);
+                    }
+                 }
+                 else
+                 {
+                    slot.set(itemstack1);
+                    playerinventory.setItem(index2, itemstack2);
+                    onTakeFromSlot(slot, player, itemstack2);
+                 }
+              }
+           }
+        }
+        else if (clicktype == ClickType.CLONE && player.abilities.instabuild && playerinventory.getCarried().isEmpty() && index1 >= 0)
+        {
+            Slot slot4 = this.slots.get(index1);
+            if (slot4 != null && slot4.hasItem())
+            {
+                ItemStack itemstack7 = slot4.getItem().copy();
+                itemstack7.setCount(itemstack7.getMaxStackSize());
+                playerinventory.setCarried(itemstack7);
+            }
+        }
+        else if (clicktype == ClickType.THROW && playerinventory.getCarried().isEmpty() && index1 >= 0)
+        {
+            Slot slot3 = this.slots.get(index1);
+            if (slot3 != null && slot3.hasItem() && slot3.mayPickup(player))
+            {
+                ItemStack itemstack6 = slot3.remove(index2 == 0 ? 1 : slot3.getItem().getCount());
+                onTakeFromSlot(slot3, player, itemstack6);
+                player.drop(itemstack6, true);
+            }
+        }
+        else if (clicktype == ClickType.PICKUP_ALL && index1 >= 0)
+        {
+            Slot slot2 = this.slots.get(index1);
+            ItemStack itemstack5 = playerinventory.getCarried();
+            if (!itemstack5.isEmpty() && (slot2 == null || !slot2.hasItem() || !slot2.mayPickup(player)))
+            {
+                int j1 = index2 == 0 ? 0 : this.slots.size() - 1;
+                int i2 = index2 == 0 ? 1 : -1;
+
+                for(int j = 0; j < 2; ++j)
+                {
+                    for(int k = j1; k >= 0 && k < this.slots.size() && itemstack5.getCount() < itemstack5.getMaxStackSize(); k += i2)
+                    {
+                        Slot slot1 = this.slots.get(k);
+                        if (slot1.hasItem() && canItemQuickReplace(slot1, itemstack5, true) && slot1.mayPickup(player) && this.canTakeItemForPickAll(itemstack5, slot1))
+                        {
+                            ItemStack itemstack3 = slot1.getItem();
+                            if (j != 0 || itemstack3.getCount() != itemstack3.getMaxStackSize())
+                            {
+                                int l = Math.min(itemstack5.getMaxStackSize() - itemstack5.getCount(), itemstack3.getCount());
+                                ItemStack itemstack4 = slot1.remove(l);
+                                itemstack5.grow(l);
+                                if (itemstack4.isEmpty())
+                                {
+                                   slot1.set(ItemStack.EMPTY);
+                                }
+
+                                onTakeFromSlot(slot1, player, itemstack4);
+                            }
+                        }
+                    }
+                }
+            }
+
+            this.broadcastChanges();
+        }
+
+        return itemstack;
+   }
+}

src/main/java/magistu/siegemachines/gui/SiegeWorkbenchScreen.java

@@ -0,0 +1,75 @@
+package magistu.siegemachines.gui;
+
+import com.mojang.blaze3d.matrix.MatrixStack;
+import com.mojang.blaze3d.systems.RenderSystem;
+import magistu.siegemachines.SiegeMachines;
+import net.minecraft.client.gui.screen.inventory.ContainerScreen;
+import net.minecraft.client.gui.widget.button.ImageButton;
+import net.minecraft.entity.player.PlayerInventory;
+import net.minecraft.inventory.container.WorkbenchContainer;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import org.jetbrains.annotations.NotNull;
+
+@OnlyIn(Dist.CLIENT)
+public class SiegeWorkbenchScreen extends ContainerScreen<SiegeWorkbenchContainer>
+{
+	private static final ResourceLocation DISPLAY_CASE_GUI = new ResourceLocation(SiegeMachines.ID,
+			"textures/gui/siege_workbench.png");
+
+	public SiegeWorkbenchScreen(SiegeWorkbenchContainer screenContainer, PlayerInventory inv, ITextComponent titleIn)
+    {
+		super(screenContainer, inv, titleIn);
+	}
+
+	@Override
+	public void render(MatrixStack matrixStack, int mouseX, int mouseY, float partialTicks)
+    {
+		this.renderBackground(matrixStack);
+		super.render(matrixStack, mouseX, mouseY, partialTicks);
+		this.renderTooltip(matrixStack, mouseX, mouseY);
+	}
+
+    @Override
+	protected void renderTooltip(@NotNull MatrixStack matrixStack, int x, int y)
+    {
+		if (this.minecraft.player.inventory.getCarried().isEmpty() && this.hoveredSlot != null && this.hoveredSlot.hasItem())
+		{
+    		this.renderTooltip(matrixStack, this.hoveredSlot.getItem(), x, y);
+		}
+	}
+
+	@Override
+	protected void init()
+	{
+		super.init();
+		this.titleLabelX = 29;
+	}
+
+	@SuppressWarnings("deprecation")
+	@Override
+	protected void renderBg(@NotNull MatrixStack matrixStack, float partialTicks, int mouseX, int mouseY)
+    {
+		RenderSystem.color4f(1.0F, 1.0F, 1.0F, 1.0F);
+		assert this.minecraft != null;
+		this.minecraft.getTextureManager().bind(DISPLAY_CASE_GUI);
+    	int i = this.leftPos;
+    	int j = (this.height - this.imageHeight) / 2;
+    	this.blit(matrixStack, i, j, 0, 0, this.imageWidth, this.imageHeight);
+	}
+
+	@Override
+	public boolean keyPressed(int key, int b, int c)
+	{
+		assert this.minecraft != null;
+		if (key == 256)
+		{
+			assert this.minecraft.player != null;
+			this.minecraft.player.closeContainer();
+			return true;
+		}
+		return super.keyPressed(key, b, c);
+	}
+}

src/main/java/magistu/siegemachines/item/MachineItem.java

@@ -0,0 +1,272 @@
+package magistu.siegemachines.item;
+
+import magistu.siegemachines.SiegeMachines;
+import magistu.siegemachines.entity.EntityTypes;
+import magistu.siegemachines.entity.machine.Machine;
+import magistu.siegemachines.entity.machine.MachineType;
+import magistu.siegemachines.entity.projectile.ProjectileBuilder;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.Blocks;
+import net.minecraft.block.FlowingFluidBlock;
+import net.minecraft.client.util.ITooltipFlag;
+import net.minecraft.entity.*;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.ItemUseContext;
+import net.minecraft.nbt.CompoundNBT;
+import net.minecraft.stats.Stats;
+import net.minecraft.tileentity.MobSpawnerTileEntity;
+import net.minecraft.tileentity.TileEntity;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.ActionResultType;
+import net.minecraft.util.Direction;
+import net.minecraft.util.Hand;
+import net.minecraft.util.math.*;
+import net.minecraft.util.math.shapes.VoxelShape;
+import net.minecraft.util.math.shapes.VoxelShapes;
+import net.minecraft.util.text.ITextComponent;
+import net.minecraft.util.text.StringTextComponent;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.util.text.TranslationTextComponent;
+import net.minecraft.world.IWorldReader;
+import net.minecraft.world.World;
+import net.minecraft.world.server.ServerWorld;
+import net.minecraft.world.spawner.AbstractSpawner;
+import org.jetbrains.annotations.NotNull;
+import software.bernie.geckolib3.core.IAnimatable;
+import software.bernie.geckolib3.core.manager.AnimationData;
+import software.bernie.geckolib3.core.manager.AnimationFactory;
+
+import javax.annotation.Nullable;
+import java.util.List;
+import java.util.Locale;
+import java.util.Objects;
+import java.util.stream.Stream;
+
+public class MachineItem extends Item implements IAnimatable
+{
+    private final AnimationFactory factory = new AnimationFactory(this);
+
+    private final String entitykey;
+    private final String typekey;
+
+    public MachineItem(Item.Properties prop, String entitykey, String typekey)
+    {
+        super(prop.stacksTo(1));
+        this.entitykey = entitykey;
+        this.typekey = typekey;
+    }
+
+    @Override
+    public void appendHoverText(@NotNull ItemStack stack, @Nullable World worldIn, List<ITextComponent> tooltip, ITooltipFlag flagIn)
+    {
+        ProjectileBuilder[] ammo = MachineType.valueOf(this.typekey).ammo;
+        if (ammo.length > 0)
+        {
+            tooltip.add(new TranslationTextComponent(SiegeMachines.ID + ".ammo").withStyle(TextFormatting.BLUE));
+            for (ProjectileBuilder builder : ammo)
+            {
+                if (MachineType.valueOf(this.typekey).usesgunpowder)
+                {
+                    tooltip.add(new StringTextComponent("Uses gunpowder").withStyle(TextFormatting.BLUE));
+                }
+                tooltip.add(new StringTextComponent("    ").append(new TranslationTextComponent(builder.item.getDescriptionId())).withStyle(TextFormatting.BLUE));
+            }
+        }
+    }
+
+    @Override
+    public @NotNull ActionResultType useOn(ItemUseContext p_195939_1_)
+    {
+        World world = p_195939_1_.getLevel();
+        if (!(world instanceof ServerWorld))
+        {
+            return ActionResultType.SUCCESS;
+        }
+        else
+        {
+            ItemStack itemstack = p_195939_1_.getItemInHand();
+            BlockPos blockpos = p_195939_1_.getClickedPos();
+            Direction direction = p_195939_1_.getClickedFace();
+            BlockState blockstate = world.getBlockState(blockpos);
+            if (blockstate.is(Blocks.SPAWNER))
+            {
+                TileEntity tileentity = world.getBlockEntity(blockpos);
+                if (tileentity instanceof MobSpawnerTileEntity)
+                {
+                    AbstractSpawner abstractspawner = ((MobSpawnerTileEntity)tileentity).getSpawner();
+                    EntityType<?> entitytype1 = this.getType(itemstack.getTag());
+                    abstractspawner.setEntityId(entitytype1);
+                    tileentity.setChanged();
+                    world.sendBlockUpdated(blockpos, blockstate, blockstate, 3);
+                    itemstack.shrink(1);
+                    return ActionResultType.CONSUME;
+                }
+            }
+
+            BlockPos blockpos1;
+            if (blockstate.getCollisionShape(world, blockpos).isEmpty())
+            {
+                blockpos1 = blockpos;
+            }
+            else
+            {
+                blockpos1 = blockpos.relative(direction);
+            }
+
+            EntityType<?> entitytype = this.getType(itemstack.getTag());
+            Entity entity = this.spawn(entitytype, (ServerWorld)world, itemstack, p_195939_1_.getPlayer(), blockpos1, SpawnReason.SPAWN_EGG, true, !Objects.equals(blockpos, blockpos1) && direction == Direction.UP, p_195939_1_.getRotation());
+
+            if (entity instanceof Machine)
+            {
+                ((Machine)entity).deploymentticks = 200;
+            }
+            if (entity != null)
+            {
+                itemstack.shrink(1);
+            }
+
+            return ActionResultType.CONSUME;
+        }
+    }
+
+    protected static double getYOffset(IWorldReader p_208051_0_, BlockPos p_208051_1_, boolean p_208051_2_, AxisAlignedBB p_208051_3_) {
+        AxisAlignedBB axisalignedbb = new AxisAlignedBB(p_208051_1_);
+        if (p_208051_2_) {
+            axisalignedbb = axisalignedbb.expandTowards(0.0D, -1.0D, 0.0D);
+        }
+
+        Stream<VoxelShape> stream = p_208051_0_.getCollisions((Entity)null, axisalignedbb, (p_233596_0_) -> {
+            return true;
+        });
+        return 1.0D + VoxelShapes.collide(Direction.Axis.Y, p_208051_3_, stream, p_208051_2_ ? -2.0D : -1.0D);
+    }
+
+    @Nullable
+    public Entity spawn(EntityType<?> entitytype, ServerWorld p_220331_1_, @Nullable ItemStack p_220331_2_, @Nullable PlayerEntity p_220331_3_, BlockPos p_220331_4_, SpawnReason p_220331_5_, boolean p_220331_6_, boolean p_220331_7_, float yaw) {
+        return this.spawn(entitytype, p_220331_1_, p_220331_2_ == null ? null : p_220331_2_.getTag(), p_220331_2_ != null && p_220331_2_.hasCustomHoverName() ? p_220331_2_.getHoverName() : null, p_220331_3_, p_220331_4_, p_220331_5_, p_220331_6_, p_220331_7_, yaw);
+    }
+
+    @Nullable
+    public Entity spawn(EntityType<?> entitytype, ServerWorld p_220342_1_, @Nullable CompoundNBT p_220342_2_, @Nullable ITextComponent p_220342_3_, @Nullable PlayerEntity p_220342_4_, BlockPos p_220342_5_, SpawnReason p_220342_6_, boolean p_220342_7_, boolean p_220342_8_, float yaw) {
+        Entity t = this.create(entitytype, p_220342_1_, p_220342_2_, p_220342_3_, p_220342_4_, p_220342_5_, p_220342_6_, p_220342_7_, p_220342_8_, yaw);
+        if (t != null) {
+            if (t instanceof net.minecraft.entity.MobEntity && net.minecraftforge.event.ForgeEventFactory.doSpecialSpawn((net.minecraft.entity.MobEntity) t, p_220342_1_, p_220342_5_.getX(), p_220342_5_.getY(), p_220342_5_.getZ(), null, p_220342_6_)) return null;
+            p_220342_1_.addFreshEntityWithPassengers(t);
+        }
+
+        return t;
+    }
+
+    @Nullable
+    public Entity create(EntityType<?> entitytype, ServerWorld p_220349_1_, @Nullable CompoundNBT p_220349_2_, @Nullable ITextComponent p_220349_3_, @Nullable PlayerEntity p_220349_4_, BlockPos p_220349_5_, SpawnReason p_220349_6_, boolean p_220349_7_, boolean p_220349_8_, float yaw) {
+        Entity t = entitytype.create(p_220349_1_);
+        if (t == null) {
+            return null;
+        } else {
+            double d0;
+            if (p_220349_7_) {
+                t.setPos((double)p_220349_5_.getX() + 0.5D, (double)(p_220349_5_.getY() + 1), (double)p_220349_5_.getZ() + 0.5D);
+                d0 = getYOffset(p_220349_1_, p_220349_5_, p_220349_8_, t.getBoundingBox());
+            } else {
+                d0 = 0.0D;
+            }
+
+            EntityType.updateCustomEntityTag(p_220349_1_, p_220349_4_, t, p_220349_2_);
+
+            if (p_220349_3_ != null && t instanceof LivingEntity) {
+                t.setCustomName(p_220349_3_);
+            }
+
+            t.moveTo((double)p_220349_5_.getX() + 0.5D, (double)p_220349_5_.getY() + d0, (double)p_220349_5_.getZ() + 0.5D, MathHelper.wrapDegrees(yaw), 0.0F);
+            if (t instanceof MobEntity) {
+                MobEntity mobentity = (MobEntity)t;
+                mobentity.yHeadRot = mobentity.yRot;
+                mobentity.yBodyRot = mobentity.yRot;
+                mobentity.finalizeSpawn(p_220349_1_, p_220349_1_.getCurrentDifficultyAt(mobentity.blockPosition()), p_220349_6_, (ILivingEntityData)null, p_220349_2_);
+                mobentity.playAmbientSound();
+            }
+
+            return t;
+        }
+    }
+
+    @Override
+    public @NotNull ActionResult<ItemStack> use(@NotNull World level, PlayerEntity player, @NotNull Hand hand)
+    {
+        ItemStack itemstack = player.getItemInHand(hand);
+        BlockRayTraceResult raytraceresult = getPlayerPOVHitResult(level, player, RayTraceContext.FluidMode.SOURCE_ONLY);
+        if (raytraceresult.getType() != RayTraceResult.Type.BLOCK)
+        {
+            return ActionResult.pass(itemstack);
+        }
+        else if (!(level instanceof ServerWorld))
+        {
+            return ActionResult.success(itemstack);
+        }
+        else
+        {
+            BlockPos blockpos = raytraceresult.getBlockPos();
+            if (!(level.getBlockState(blockpos).getBlock() instanceof FlowingFluidBlock))
+            {
+                return ActionResult.pass(itemstack);
+            }
+            else if (level.mayInteract(player, blockpos) && player.mayUseItemAt(blockpos, raytraceresult.getDirection(), itemstack))
+            {
+                EntityType<?> entitytype = this.getType(itemstack.getTag());
+                Entity entity = this.spawn(entitytype, (ServerWorld) level, itemstack, player, blockpos, SpawnReason.SPAWN_EGG, false, false, player.yRot);
+                if (entity instanceof Machine)
+                {
+                    ((Machine)entity).deploymentticks = 200;
+                }
+                if (entity != null)
+                {
+                    if (!player.isCreative())
+                    {
+                        itemstack.shrink(1);
+                    }
+                    player.awardStat(Stats.ITEM_USED.get(this));
+                    return ActionResult.consume(itemstack);
+                }
+                else
+                {
+                    return ActionResult.pass(itemstack);
+                }
+
+            }
+            else
+            {
+                return ActionResult.fail(itemstack);
+            }
+        }
+    }
+
+    public EntityType<?> getType(@Nullable CompoundNBT nbt)
+    {
+        EntityType<?> defaulttype = EntityTypes.DEFERRED_REGISTER.getEntries().stream().filter(r -> r.get().getRegistryName().getPath().equals(this.entitykey)).findFirst().get().get();
+
+        if (nbt != null && nbt.contains("EntityTag", 10))
+        {
+            CompoundNBT compoundnbt = nbt.getCompound("EntityTag");
+            if (compoundnbt.contains("id", 8))
+            {
+                return EntityType.byString(compoundnbt.getString("id")).orElse(defaulttype);
+            }
+        }
+
+        return defaulttype;
+    }
+
+    @Override
+    public void registerControllers(AnimationData data)
+    {
+
+    }
+
+    @Override
+    public AnimationFactory getFactory()
+    {
+        return this.factory;
+    }
+}

src/main/java/magistu/siegemachines/item/ModItems.java

@@ -0,0 +1,59 @@
+package magistu.siegemachines.item;
+
+import magistu.siegemachines.SiegeMachines;
+import magistu.siegemachines.block.ModBlocks;
+import magistu.siegemachines.client.renderer.*;
+import net.minecraft.block.AbstractBlock;
+import net.minecraft.block.CraftingTableBlock;
+import net.minecraft.block.SoundType;
+import net.minecraft.block.material.Material;
+import net.minecraft.item.BlockItem;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemGroup;
+import net.minecraft.item.ItemStack;
+import net.minecraftforge.event.RegistryEvent;
+import net.minecraftforge.eventbus.api.IEventBus;
+import net.minecraftforge.eventbus.api.SubscribeEvent;
+import net.minecraftforge.fml.RegistryObject;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.registries.DeferredRegister;
+import net.minecraftforge.registries.ForgeRegistries;
+import net.minecraftforge.registries.IForgeRegistry;
+import org.jetbrains.annotations.NotNull;
+
+@Mod.EventBusSubscriber(bus = Mod.EventBusSubscriber.Bus.MOD)
+public class ModItems
+{
+    public static final ItemGroup GROUP_SM = new ItemGroup(SiegeMachines.ID + ".medieval_siege_machines")
+    {
+        public @NotNull ItemStack makeIcon()
+        {
+            return new ItemStack(ModItems.MORTAR.get());
+        }
+    };
+
+    public static final DeferredRegister<Item> ITEMS = DeferredRegister.create(ForgeRegistries.ITEMS, SiegeMachines.ID);
+
+    public static final RegistryObject<MachineItem> MORTAR = ITEMS.register("mortar", () -> new MachineItem(new Item.Properties().tab(ModItems.GROUP_SM).setISTER(() -> MortarItemGeoRenderer::new), "mortar", "MORTAR"));
+    //public static final RegistryObject<MachineItem> CULVERIN = ITEMS.register("culverin", () -> new MachineItem(new Item.Properties().tab(ModItems.GROUP_SM).setISTER(() -> CulverinItemGeoRenderer::new), "culverin", "CULVERIN"));
+    public static final RegistryObject<MachineItem> CATAPULT = ITEMS.register("catapult", () -> new MachineItem(new Item.Properties().tab(ModItems.GROUP_SM).setISTER(() -> CatapultItemGeoRenderer::new), "catapult", "CATAPULT"));
+    public static final RegistryObject<MachineItem> TREBUCHET = ITEMS.register("trebuchet", () -> new MachineItem(new Item.Properties().tab(ModItems.GROUP_SM).setISTER(() -> TrebuchetItemGeoRenderer::new), "trebuchet", "TREBUCHET"));
+    public static final RegistryObject<MachineItem> BALLISTA = ITEMS.register("ballista", () -> new MachineItem(new Item.Properties().tab(ModItems.GROUP_SM).setISTER(() -> BallistaItemGeoRenderer::new), "ballista", "BALLISTA"));
+    public static final RegistryObject<MachineItem> BATTERING_RAM = ITEMS.register("battering_ram", () -> new MachineItem(new Item.Properties().tab(ModItems.GROUP_SM).setISTER(() -> BatteringRamItemGeoRenderer::new), "battering_ram", "BATTERING_RAM"));
+
+    public static final RegistryObject<Item> CANNONBALL = ITEMS.register("cannonball", () -> new Item(new Item.Properties().stacksTo(16).tab(ModItems.GROUP_SM)));
+    public static final RegistryObject<Item> STONE = ITEMS.register("stone", () -> new Item(new Item.Properties().stacksTo(16)));
+    public static final RegistryObject<Item> GIANT_STONE = ITEMS.register("giant_stone", () -> new Item(new Item.Properties().stacksTo(16)));
+    public static final RegistryObject<Item> GIANT_ARROW = ITEMS.register("giant_arrow", () -> new Item(new Item.Properties().stacksTo(16).tab(ModItems.GROUP_SM)));
+
+    public static final RegistryObject<Item> TURRET_BASE = ITEMS.register("turret_base", () -> new Item(new Item.Properties().tab(ModItems.GROUP_SM)));
+    public static final RegistryObject<Item> BEAM = ITEMS.register("beam", () -> new Item(new Item.Properties().tab(ModItems.GROUP_SM)));
+    public static final RegistryObject<Item> COUNTERWEIGHT = ITEMS.register("counterweight", () -> new Item(new Item.Properties().tab(ModItems.GROUP_SM)));
+    public static final RegistryObject<Item> BARREL = ITEMS.register("barrel", () -> new Item(new Item.Properties().tab(ModItems.GROUP_SM)));
+    public static final RegistryObject<Item> WHEEL = ITEMS.register("wheel", () -> new Item(new Item.Properties().tab(ModItems.GROUP_SM)));
+
+    public static void register(IEventBus eventBus)
+    {
+        ITEMS.register(eventBus);
+    }
+}

src/main/java/magistu/siegemachines/network/PacketHandler.java

@@ -0,0 +1,66 @@
+package magistu.siegemachines.network;
+
+import magistu.siegemachines.SiegeMachines;
+import net.minecraft.entity.player.ServerPlayerEntity;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.BlockPos;
+import net.minecraftforge.fml.network.NetworkDirection;
+import net.minecraftforge.fml.network.NetworkRegistry;
+import net.minecraftforge.fml.network.simple.SimpleChannel;
+import net.minecraftforge.fml.server.ServerLifecycleHooks;
+
+public class PacketHandler
+{
+    private static final String PROTOCOL_VERSION = "1";
+
+    public static final SimpleChannel INSTANCE = NetworkRegistry.newSimpleChannel(new ResourceLocation(SiegeMachines.ID, "main"), () -> "1", "1"::equals, "1"::equals);
+
+    protected static int currentId = 0;
+
+    public static void init()
+    {
+        INSTANCE.registerMessage(getNextId(), PacketMachine.class, PacketMachine::write, PacketMachine::read, PacketMachine.Handler::handle);
+        INSTANCE.registerMessage(getNextId(), PacketMachineControl.class, PacketMachineControl::write, PacketMachineControl::read, PacketMachineControl.Handler::handle);
+        INSTANCE.registerMessage(getNextId(), PacketMachineUse.class, PacketMachineUse::write, PacketMachineUse::read, PacketMachineUse.Handler::handle);
+        INSTANCE.registerMessage(getNextId(), PacketMachineUseRealise.class, PacketMachineUseRealise::write, PacketMachineUseRealise::read, PacketMachineUseRealise.Handler::handle);
+        INSTANCE.registerMessage(getNextId(), PacketOpenMachineInventory.class, PacketOpenMachineInventory::write, PacketOpenMachineInventory::read, PacketOpenMachineInventory.Handler::handle);
+        INSTANCE.registerMessage(getNextId(), PacketMachineInventorySlot.class, PacketMachineInventorySlot::write, PacketMachineInventorySlot::read, PacketMachineInventorySlot.Handler::handle);
+
+    }
+
+    public static int getNextId()
+    {
+        int id = currentId;
+        currentId++;
+        return id;
+    }
+
+    public static void sendToServer(Object packet) {
+        INSTANCE.sendToServer(packet);
+    }
+
+    public static void sendTo(Object packet, ServerPlayerEntity player)
+    {
+        if (!(player instanceof net.minecraftforge.common.util.FakePlayer))
+            INSTANCE.sendTo(packet, player.connection.connection, NetworkDirection.PLAY_TO_CLIENT);
+    }
+
+    public static void sendPacketToAllInArea(Object packet, BlockPos center, int rangesqr)
+    {
+        for (ServerPlayerEntity player : ServerLifecycleHooks.getCurrentServer().getPlayerList().getPlayers())
+        {
+            if (player.distanceToSqr(center.getX(), center.getY(), center.getZ()) < rangesqr)
+            {
+                sendTo(packet, player);
+            }
+        }
+    }
+
+    public static void sendPacketToAll(Object packet)
+    {
+        for (ServerPlayerEntity player : ServerLifecycleHooks.getCurrentServer().getPlayerList().getPlayers())
+        {
+            sendTo(packet, player);
+        }
+    }
+}

src/main/java/magistu/siegemachines/network/PacketMachine.java

@@ -0,0 +1,81 @@
+package magistu.siegemachines.network;
+
+import io.netty.channel.ChannelHandler;
+import magistu.siegemachines.entity.machine.Machine;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.entity.player.ClientPlayerEntity;
+import net.minecraft.entity.Entity;
+import net.minecraft.network.PacketBuffer;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import net.minecraftforge.fml.LogicalSide;
+import net.minecraftforge.fml.network.NetworkEvent;
+
+import java.util.function.Supplier;
+
+@ChannelHandler.Sharable
+public class PacketMachine
+{
+	private final int entityid;
+	private final int delayticks;
+	private final int useticks;
+	private final float turretyaw;
+	private final float turretpitch;
+
+	public PacketMachine(int entityid, int delayticks, int useticks, float turretpitch, float turretyaw)
+	{
+		this.entityid = entityid;
+		this.delayticks = delayticks;
+		this.useticks = useticks;
+		this.turretpitch = turretpitch;
+		this.turretyaw = turretyaw;
+	}
+
+	public static PacketMachine read(PacketBuffer buf)
+    {
+        return new PacketMachine(buf.readInt(), buf.readInt(), buf.readInt(), buf.readFloat(), buf.readFloat());
+    }
+
+	public static void write(PacketMachine message, PacketBuffer buf)
+    {
+		buf.writeInt(message.entityid);
+		buf.writeInt(message.delayticks);
+		buf.writeInt(message.useticks);
+		buf.writeFloat(message.turretpitch);
+		buf.writeFloat(message.turretyaw);
+	}
+
+	public static class Handler
+    {
+        public static void handle(PacketMachine packet, Supplier<NetworkEvent.Context> ctx)
+        {
+            NetworkEvent.Context context = ctx.get();
+            if (context.getDirection().getReceptionSide() == LogicalSide.CLIENT)
+            {
+                context.enqueueWork(() -> PacketMachine.handleClientSide(packet));
+			}
+            context.setPacketHandled(true);
+        }
+    }
+
+	@OnlyIn(Dist.CLIENT)
+	public static void handleClientSide(PacketMachine packet)
+	{
+		ClientPlayerEntity player = Minecraft.getInstance().player;
+		if(packet == null || player == null || player.level == null)
+		{
+			return;
+		}
+
+		Entity entity = player.level.getEntity(packet.entityid);
+        if (!(entity instanceof Machine))
+        {
+            return;
+        }
+		Machine machine = (Machine) entity;
+
+		machine.delayticks = packet.delayticks;
+		machine.useticks = packet.useticks;
+		machine.setTurretRotations(packet.turretpitch, packet.turretyaw);
+	}
+}

src/main/java/magistu/siegemachines/network/PacketMachineControl.java

@@ -0,0 +1,54 @@
+package magistu.siegemachines.network;
+
+import io.netty.channel.ChannelHandler;
+import magistu.siegemachines.entity.machine.Machine;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.ServerPlayerEntity;
+import net.minecraft.network.PacketBuffer;
+import net.minecraftforge.fml.LogicalSide;
+import net.minecraftforge.fml.network.NetworkEvent;
+
+import java.util.function.Supplier;
+
+@ChannelHandler.Sharable
+public class PacketMachineControl
+{
+	public PacketMachineControl() {}
+
+	public static PacketMachineControl read(PacketBuffer buf)
+    {
+        return new PacketMachineControl();
+    }
+
+	public static void write(PacketMachineControl message, PacketBuffer buf) {}
+
+	public static class Handler
+    {
+        public static void handle(PacketMachineControl packet, Supplier<NetworkEvent.Context> ctx)
+        {
+            NetworkEvent.Context context = ctx.get();
+            if (context.getDirection().getReceptionSide() == LogicalSide.SERVER)
+            {
+                context.enqueueWork(() -> PacketMachineControl.handleServerSide(packet, context.getSender()));
+			}
+            context.setPacketHandled(true);
+        }
+    }
+
+	public static void handleServerSide(PacketMachineControl packet, ServerPlayerEntity player)
+	{
+		if(packet == null || player == null || !player.isPassenger())
+		{
+			return;
+		}
+
+		Entity entity = player.getVehicle();
+        if (!(entity instanceof Machine))
+        {
+            return;
+        }
+		Machine machine = (Machine) entity;
+
+		machine.setTurretRotations(player.xRot, player.yRot);
+	}
+}

src/main/java/magistu/siegemachines/network/PacketMachineInventorySlot.java

@@ -0,0 +1,83 @@
+package magistu.siegemachines.network;
+
+import io.netty.channel.ChannelHandler;
+import magistu.siegemachines.entity.machine.Machine;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.entity.player.ClientPlayerEntity;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.item.ItemStack;
+import net.minecraft.network.PacketBuffer;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import net.minecraftforge.fml.LogicalSide;
+import net.minecraftforge.fml.network.NetworkEvent;
+
+import java.util.function.Supplier;
+
+@ChannelHandler.Sharable
+public class PacketMachineInventorySlot
+{
+    private final int entityid;
+    private final int slot;
+    private ItemStack itemstack = ItemStack.EMPTY;
+
+    public PacketMachineInventorySlot(int entityid, int slot, ItemStack itemstack)
+    {
+        this.entityid = entityid;
+        this.slot = slot;
+        this.itemstack = itemstack.copy();
+    }
+
+    public static PacketMachineInventorySlot read(PacketBuffer buf)
+    {
+        return new PacketMachineInventorySlot(buf.readInt(), buf.readInt(), buf.readItem());
+    }
+
+    public static void write(PacketMachineInventorySlot message, PacketBuffer buf)
+    {
+        buf.writeInt(message.entityid);
+        buf.writeInt(message.slot);
+        buf.writeItemStack(message.itemstack, false);
+    }
+
+    public static class Handler
+    {
+        public static void handle(PacketMachineInventorySlot packet, Supplier<NetworkEvent.Context> ctx)
+        {
+            NetworkEvent.Context context = ctx.get();
+            if (context.getDirection().getReceptionSide() == LogicalSide.SERVER)
+            {
+                context.enqueueWork(() -> PacketMachineInventorySlot.handleEachSide(packet, context.getSender()));
+			}
+			else if (context.getDirection().getReceptionSide() == LogicalSide.CLIENT)
+			{
+                context.enqueueWork(() -> PacketMachineInventorySlot.handleClientSide(packet));
+			}
+            context.setPacketHandled(true);
+        }
+    }
+
+    @OnlyIn(Dist.CLIENT)
+	public static void handleClientSide(PacketMachineInventorySlot packet)
+	{
+		handleEachSide(packet, Minecraft.getInstance().player);
+	}
+
+	public static void handleEachSide(PacketMachineInventorySlot packet, PlayerEntity player)
+	{
+        if(packet == null || player == null || player.level == null)
+        {
+            return;
+        }
+
+        Entity entity = player.level.getEntity(packet.entityid);
+        if (!(entity instanceof Machine))
+        {
+            return;
+        }
+        Machine machine = (Machine) entity;
+
+        machine.inventory.setItem(packet.slot, packet.itemstack);
+    }
+}

src/main/java/magistu/siegemachines/network/PacketMachineUse.java

@@ -0,0 +1,75 @@
+package magistu.siegemachines.network;
+
+import io.netty.channel.ChannelHandler;
+import magistu.siegemachines.entity.machine.Machine;
+import net.minecraft.client.Minecraft;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.network.PacketBuffer;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import net.minecraftforge.fml.LogicalSide;
+import net.minecraftforge.fml.network.NetworkEvent;
+
+import java.util.function.Supplier;
+
+@ChannelHandler.Sharable
+public class PacketMachineUse
+{
+	private final int entityid;
+
+	public PacketMachineUse(int entityid)
+	{
+		this.entityid = entityid;
+	}
+
+	public static PacketMachineUse read(PacketBuffer buf)
+    {
+        return new PacketMachineUse(buf.readInt());
+    }
+
+	public static void write(PacketMachineUse message, PacketBuffer buf)
+    {
+		buf.writeInt(message.entityid);
+	}
+
+	public static class Handler
+    {
+        public static void handle(PacketMachineUse packet, Supplier<NetworkEvent.Context> ctx)
+        {
+            NetworkEvent.Context context = ctx.get();
+            if (context.getDirection().getReceptionSide() == LogicalSide.SERVER)
+            {
+                context.enqueueWork(() -> PacketMachineUse.handleEachSide(packet, context.getSender()));
+			}
+			else if (context.getDirection().getReceptionSide() == LogicalSide.CLIENT)
+			{
+                context.enqueueWork(() -> PacketMachineUse.handleClientSide(packet));
+			}
+            context.setPacketHandled(true);
+        }
+    }
+
+	@OnlyIn(Dist.CLIENT)
+	public static void handleClientSide(PacketMachineUse packet)
+	{
+		handleEachSide(packet, Minecraft.getInstance().player);
+	}
+
+	public static void handleEachSide(PacketMachineUse packet, PlayerEntity player)
+	{
+		if(packet == null || player == null || player.level == null)
+		{
+			return;
+		}
+
+		Entity entity = player.level.getEntity(packet.entityid);
+        if (!(entity instanceof Machine))
+        {
+            return;
+        }
+		Machine machine = (Machine) entity;
+
+        machine.use(player);
+	}
+}

src/main/java/magistu/siegemachines/network/PacketMachineUseRealise.java

@@ -0,0 +1,75 @@
+package magistu.siegemachines.network;
+
+import io.netty.channel.ChannelHandler;
+import magistu.siegemachines.entity.machine.Machine;
+import net.minecraft.client.Minecraft;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.network.PacketBuffer;
+import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.api.distmarker.OnlyIn;
+import net.minecraftforge.fml.LogicalSide;
+import net.minecraftforge.fml.network.NetworkEvent;
+
+import java.util.function.Supplier;
+
+@ChannelHandler.Sharable
+public class PacketMachineUseRealise
+{
+	private final int entityid;
+
+	public PacketMachineUseRealise(int entityid)
+	{
+		this.entityid = entityid;
+	}
+
+	public static PacketMachineUseRealise read(PacketBuffer buf)
+    {
+        return new PacketMachineUseRealise(buf.readInt());
+    }
+
+	public static void write(PacketMachineUseRealise message, PacketBuffer buf)
+    {
+		buf.writeInt(message.entityid);
+	}
+
+	public static class Handler
+    {
+        public static void handle(PacketMachineUseRealise packet, Supplier<NetworkEvent.Context> ctx)
+        {
+            NetworkEvent.Context context = ctx.get();
+            if (context.getDirection().getReceptionSide() == LogicalSide.SERVER)
+            {
+                context.enqueueWork(() -> PacketMachineUseRealise.handleEachSide(packet, context.getSender()));
+			}
+			else if (context.getDirection().getReceptionSide() == LogicalSide.CLIENT)
+			{
+                context.enqueueWork(() -> PacketMachineUseRealise.handleClientSide(packet));
+			}
+            context.setPacketHandled(true);
+        }
+    }
+
+	@OnlyIn(Dist.CLIENT)
+	public static void handleClientSide(PacketMachineUseRealise packet)
+	{
+		handleEachSide(packet, Minecraft.getInstance().player);
+	}
+
+	public static void handleEachSide(PacketMachineUseRealise packet, PlayerEntity player)
+	{
+		if(packet == null || player == null || player.level == null)
+		{
+			return;
+		}
+
+		Entity entity = player.level.getEntity(packet.entityid);
+        if (!(entity instanceof Machine))
+        {
+            return;
+        }
+		Machine machine = (Machine) entity;
+
+        machine.useRealise();
+	}
+}

src/main/java/magistu/siegemachines/network/PacketOpenMachineInventory.java

@@ -0,0 +1,54 @@
+package magistu.siegemachines.network;
+
+import io.netty.channel.ChannelHandler;
+import magistu.siegemachines.entity.machine.Machine;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.ServerPlayerEntity;
+import net.minecraft.network.PacketBuffer;
+import net.minecraftforge.fml.LogicalSide;
+import net.minecraftforge.fml.network.NetworkEvent;
+
+import java.util.function.Supplier;
+
+@ChannelHandler.Sharable
+public class PacketOpenMachineInventory
+{
+	public PacketOpenMachineInventory() {}
+
+	public static PacketOpenMachineInventory read(PacketBuffer buf)
+    {
+        return new PacketOpenMachineInventory();
+    }
+
+	public static void write(PacketOpenMachineInventory message, PacketBuffer buf) {}
+
+	public static class Handler
+    {
+        public static void handle(PacketOpenMachineInventory packet, Supplier<NetworkEvent.Context> ctx)
+        {
+            NetworkEvent.Context context = ctx.get();
+            if (context.getDirection().getReceptionSide() == LogicalSide.SERVER)
+            {
+                context.enqueueWork(() -> PacketOpenMachineInventory.handleServerSide(packet, context.getSender()));
+			}
+            context.setPacketHandled(true);
+        }
+    }
+
+	public static void handleServerSide(PacketOpenMachineInventory packet, ServerPlayerEntity player)
+	{
+		if(packet == null || player == null || !player.isPassenger())
+		{
+			return;
+		}
+
+		Entity entity = player.getVehicle();
+        if (!(entity instanceof Machine))
+        {
+            return;
+        }
+		Machine machine = (Machine) entity;
+
+        machine.openInventoryGui();
+	}
+}

src/main/java/magistu/siegemachines/proxy/IProxy.java

@@ -0,0 +1,13 @@
+package magistu.siegemachines.proxy;
+
+import net.minecraftforge.eventbus.api.IEventBus;
+import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
+
+public interface IProxy
+{
+    void setup(IEventBus paramIEventBus1, IEventBus paramIEventBus2);
+
+    public void clientSetup(FMLClientSetupEvent event);
+
+    public void onPreInit();
+}

src/main/java/magistu/siegemachines/server/ServerProxy.java

@@ -0,0 +1,14 @@
+package magistu.siegemachines.server;
+
+import magistu.siegemachines.proxy.IProxy;
+import net.minecraftforge.eventbus.api.IEventBus;
+import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
+
+public class ServerProxy implements IProxy
+{
+    public void setup(IEventBus modEventBus, IEventBus forgeEventBus) {}
+
+    public void clientSetup(FMLClientSetupEvent event) {}
+
+    public void onPreInit() {}
+}