public void useGadget(ThematicArmor armor, ItemStack armorStack, PlayerEntity player, ItemStack itemStack) {
        if (type.equals(Type.THROW)) {
            PersistentProjectileEntity thrown = item.createThrowable(player.getWorld(), itemStack, player);
            thrown.setVelocity(player, player.getPitch(), player.getYaw(), 0.0F, 3.0F, 1.0F);
            thrown.setPosition(player.getX(), player.getEyeY() - 0.1D, player.getZ());

            player.world.spawnEntity(thrown);
        }

        if (type.equals(Type.USE)) {
            use(armor, armorStack, player, itemStack);
        }
    }

    public abstract class ThematicEntityGadgetRenderer extends GeoEntityRenderer<ThematicThrowableEntity> {
    public ThematicEntityGadgetRenderer(EntityRendererFactory.Context renderManager, ThematicGadgetEntityModel model) {
        super(renderManager, model);
    }

    /**
     * Sets a scale override for this renderer, telling GeckoLib to pre-scale the model
     */
    public GeoEntityRenderer<ThematicThrowableEntity> withScale(float scaleWidth, float scaleHeight) {
        this.scaleWidth = scaleWidth * 0.75f;
        this.scaleHeight = scaleHeight * 0.75f;

        return this;
    }
}

public class ThematicGadgetEntityModel extends DefaultedEntityGeoModel<ThematicThrowableEntity> {
    public ThematicGadgetEntityModel(String gadgetName) {
        super(new Identifier(Mod.MOD_ID, gadgetName));
    }

    @Override
    protected String subtype() {
        return "gadget";
    }
}

public class ThematicThrowableEntity extends PersistentProjectileEntity implements GeoEntity {
    private final AnimatableInstanceCache animatableInstanceCache = GeckoLibUtil.createInstanceCache(this);
    private String id = "default";
    private ItemStack itemStack;

    @Nullable
    private ThematicGadget gadget;

    public ThematicThrowableEntity(EntityType<? extends ThematicThrowableEntity> entityType, World world) {
        super(entityType, world);
    }

    public ThematicThrowableEntity(EntityType<? extends ThematicThrowableEntity> entityType, World world, LivingEntity shooter) {
        super(entityType, world);

        this.setOwner(shooter);
    }

    public ThematicThrowableEntity(EntityType<ThematicThrowableEntity> entity, World world, LivingEntity shooter, ThematicGadget gadget) {
        super(entity, world);
        this.gadget = gadget;
        this.setOwner(shooter);
    }

    public String getID() {
        return this.id;
    }

    public void setID(String id) {
        this.id = id;
    }

    protected void onEntityHit(EntityHitResult entityHitResult) { // called on entity hit.
        super.onEntityHit(entityHitResult);

        if (gadget != null && !this.world.isClient) {
            gadget.onEntityHit(this, this.getOwner(), entityHitResult);
        }
    }

    public void setItem(ItemStack itemStack) {
        this.itemStack = itemStack;
    }

    @Override
    protected ItemStack asItemStack() {
        return itemStack;
    }

    protected void onCollision(HitResult hitResult) {
        super.onCollision(hitResult);

        if (gadget != null && !this.world.isClient) {
            gadget.onCollision(this, hitResult);
        }
    }

    @Override
    public void registerControllers(AnimatableManager.ControllerRegistrar controllers) {
        controllers.add(DefaultAnimations.genericLivingController(this));
    }

    @Override
    public AnimatableInstanceCache getAnimatableInstanceCache() {
        return this.animatableInstanceCache;
    }
}

    @Override
    public void preRender(MatrixStack poseStack, ThematicThrowableEntity animatable, BakedGeoModel model, VertexConsumerProvider bufferSource, VertexConsumer buffer, boolean isReRender, float partialTick, int packedLight, int packedOverlay, float red, float green, float blue,
                          float alpha) {
        RenderUtils.faceRotation(poseStack, animatable, partialTick);
        super.preRender(poseStack, animatable, model, bufferSource, buffer, isReRender, partialTick, packedLight, packedOverlay, red, green, blue, alpha);
    }