MidnightLib v0.1.0 for 21w08b

src/main/java/eu/midnightdust/hats/HatsClient.java

@@ -0,0 +1,29 @@
+package eu.midnightdust.hats;
+
+import eu.midnightdust.hats.bunny.BunnyEarsFeatureRenderer;
+import eu.midnightdust.hats.christmas.ChristmasHatFeatureRenderer;
+import eu.midnightdust.hats.config.HatsConfig;
+import eu.midnightdust.hats.tater.TinyPotatoFeatureRenderer;
+import eu.midnightdust.hats.web.HatLoader;
+import eu.midnightdust.hats.witch.WitchHatFeatureRenderer;
+import net.fabricmc.api.ClientModInitializer;
+import net.fabricmc.fabric.api.client.rendereregistry.v1.EntityModelLayerRegistry;
+
+@SuppressWarnings({"deprecation", "UnstableApiUsage"})
+public class HatsClient implements ClientModInitializer {
+
+    public static final String MOD_ID = "midnightlib";
+
+    @Override
+    public void onInitializeClient() {
+        HatsConfig.init("midnightlib", HatsConfig.class);
+
+        EntityModelLayerRegistry.registerModelLayer(BunnyEarsFeatureRenderer.RABBIT_EARS_MODEL_LAYER, BunnyEarsFeatureRenderer::getTexturedModelData);
+        EntityModelLayerRegistry.registerModelLayer(ChristmasHatFeatureRenderer.CHRISTMAS_HAT_MODEL_LAYER, ChristmasHatFeatureRenderer::getTexturedModelData);
+        EntityModelLayerRegistry.registerModelLayer(TinyPotatoFeatureRenderer.TINY_POTATO_MODEL_LAYER, TinyPotatoFeatureRenderer::getTexturedModelData);
+        EntityModelLayerRegistry.registerModelLayer(WitchHatFeatureRenderer.WITCH_HAT_MODEL_LAYER, WitchHatFeatureRenderer::getTexturedModelData);
+        if (HatsConfig.special_hats) {
+            HatLoader.init();
+        }
+    }
+}

src/main/java/eu/midnightdust/hats/bunny/BunnyEarsFeatureRenderer.java

@@ -0,0 +1,77 @@
+package eu.midnightdust.hats.bunny;
+
+import eu.midnightdust.hats.HatsClient;
+import eu.midnightdust.hats.config.AreEventHatsEnabled;
+import eu.midnightdust.hats.web.HatLoader;
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+import net.fabricmc.loader.api.FabricLoader;
+import net.minecraft.client.model.TexturedModelData;
+import net.minecraft.client.network.AbstractClientPlayerEntity;
+import net.minecraft.client.render.OverlayTexture;
+import net.minecraft.client.render.RenderLayer;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.render.VertexConsumerProvider;
+import net.minecraft.client.render.entity.feature.FeatureRenderer;
+import net.minecraft.client.render.entity.feature.FeatureRendererContext;
+import net.minecraft.client.render.entity.model.*;
+import net.minecraft.client.render.item.ItemRenderer;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.util.Identifier;
+
+import java.util.Calendar;
+import java.util.UUID;
+
+@Environment(EnvType.CLIENT)
+public class BunnyEarsFeatureRenderer<T extends LivingEntity, M extends EntityModel<T>> extends FeatureRenderer<T, M> {
+    private static final String MOD_ID = HatsClient.MOD_ID;
+    public static final EntityModelLayer RABBIT_EARS_MODEL_LAYER = new EntityModelLayer(new Identifier("midnight-hats","bunny_ears"), "main");
+    private static final UUID MOTSCHEN = UUID.fromString("a44c2660-630f-478f-946a-e518669fcf0c");
+
+    private static final Identifier DEACTIVATED = new Identifier(MOD_ID,"textures/hats/empty.png");
+    private static final Identifier RABBIT = new Identifier("textures/entity/rabbit/brown.png");
+    private final BunnyEarsModel<T> bunnyEars;
+
+    public BunnyEarsFeatureRenderer(FeatureRendererContext<T, M> featureRendererContext, EntityModelLoader entityModelLoader) {
+        super(featureRendererContext);
+        this.bunnyEars = new BunnyEarsModel(entityModelLoader.getModelPart(RABBIT_EARS_MODEL_LAYER));
+    }
+
+    public static TexturedModelData getTexturedModelData() {
+        return TexturedModelData.of(BunnyEarsModel.getModelData(), 64, 32);
+    }
+
+    public void render(MatrixStack matrixStack, VertexConsumerProvider vertexConsumerProvider, int i, T livingEntity, float f, float g, float h, float j, float k, float l) {
+        {
+            AbstractClientPlayerEntity abstractClientPlayerEntity = (AbstractClientPlayerEntity)livingEntity;
+            Identifier hat_type;
+            if (livingEntity != null) {
+
+                if (Calendar.getInstance().get(Calendar.MONTH) == Calendar.APRIL && Calendar.getInstance().get(Calendar.DAY_OF_MONTH) <= 4) {
+                    if (FabricLoader.getInstance().isModLoaded("cloth-config2")) {
+                        if (AreEventHatsEnabled.areEventHatsEnabled()) {
+                            hat_type = RABBIT;
+                        }
+                        else hat_type = DEACTIVATED;
+                    }
+                    else hat_type = RABBIT;
+                }else {
+                    hat_type = DEACTIVATED;
+                }
+            } else {
+                hat_type = DEACTIVATED;
+            }
+
+            if (!(hat_type == DEACTIVATED) && !HatLoader.PLAYER_HATS.containsKey(abstractClientPlayerEntity.getUuid()) && !abstractClientPlayerEntity.getUuid().equals(MOTSCHEN)) {
+                matrixStack.push();
+
+                ((ModelWithHead) this.getContextModel()).getHead().rotate(matrixStack);
+                VertexConsumer vertexConsumer = ItemRenderer.getArmorGlintConsumer(vertexConsumerProvider, RenderLayer.getEntityCutoutNoCull(hat_type), false, false);
+                this.bunnyEars.render(matrixStack, vertexConsumer, i, OverlayTexture.DEFAULT_UV, 1.0F, 1.0F, 1.0F, 1.0F);
+
+                matrixStack.pop();
+            }
+        }
+    }
+}

src/main/java/eu/midnightdust/hats/bunny/BunnyEarsModel.java

@@ -0,0 +1,44 @@
+package eu.midnightdust.hats.bunny;
+
+import net.minecraft.client.model.*;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.render.entity.model.SinglePartEntityModel;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.entity.LivingEntity;
+
+public class BunnyEarsModel<T extends LivingEntity> extends SinglePartEntityModel<T> {
+	private final ModelPart right_ear;
+
+	public BunnyEarsModel(ModelPart root) {
+		this.right_ear = root;
+
+		right_ear.setPivot(0.0F, -3.0F, -1.0F);
+
+}
+	public static ModelData getModelData(){
+		ModelData modelData = new ModelData();
+		ModelPartData modelPartData = modelData.getRoot();
+		modelPartData.addChild("right_ear", ModelPartBuilder.create().uv(52, 0).cuboid(-2.5F, -9.0F, -1.0F, 2.0F, 5.0F, 1.0F), ModelTransform.NONE);
+		modelPartData.addChild("left_ear", ModelPartBuilder.create().uv(58, 0).mirrored().cuboid(0.5F, -9.0F, -1.0F, 2.0F, 5.0F, 1.0F), ModelTransform.NONE);
+		return modelData;
+	}
+
+	public ModelPart getPart() {
+		return this.right_ear;
+	}
+
+	@Override
+	public void setAngles(T entity, float limbAngle, float limbDistance, float animationProgress, float headYaw, float headPitch) {
+	}
+
+	@Override
+	public void render(MatrixStack matrixStack, VertexConsumer buffer, int packedLight, int packedOverlay, float red, float green, float blue, float alpha){
+		right_ear.render(matrixStack, buffer, packedLight, packedOverlay);
+	}
+
+	public void setRotationAngle(ModelPart bone, float x, float y, float z) {
+		bone.pitch = x;
+		bone.yaw = y;
+		bone.roll = z;
+	}
+}

src/main/java/eu/midnightdust/hats/christmas/ChristmasHatFeatureRenderer.java

@@ -0,0 +1,79 @@
+package eu.midnightdust.hats.christmas;
+
+import eu.midnightdust.hats.HatsClient;
+import eu.midnightdust.hats.config.AreEventHatsEnabled;
+import eu.midnightdust.hats.web.HatLoader;
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+import net.fabricmc.loader.api.FabricLoader;
+import net.minecraft.client.model.TexturedModelData;
+import net.minecraft.client.network.AbstractClientPlayerEntity;
+import net.minecraft.client.render.OverlayTexture;
+import net.minecraft.client.render.RenderLayer;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.render.VertexConsumerProvider;
+import net.minecraft.client.render.entity.feature.FeatureRenderer;
+import net.minecraft.client.render.entity.feature.FeatureRendererContext;
+import net.minecraft.client.render.entity.model.EntityModel;
+import net.minecraft.client.render.entity.model.EntityModelLayer;
+import net.minecraft.client.render.entity.model.EntityModelLoader;
+import net.minecraft.client.render.entity.model.ModelWithHead;
+import net.minecraft.client.render.item.ItemRenderer;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.util.Identifier;
+
+import java.util.Calendar;
+import java.util.UUID;
+
+@Environment(EnvType.CLIENT)
+public class ChristmasHatFeatureRenderer<T extends LivingEntity, M extends EntityModel<T>> extends FeatureRenderer<T, M> {
+    private static final String MOD_ID = HatsClient.MOD_ID;
+    public static final EntityModelLayer CHRISTMAS_HAT_MODEL_LAYER = new EntityModelLayer(new Identifier("midnight-hats","christmas_hat"), "main");
+    private static final UUID MOTSCHEN = UUID.fromString("a44c2660-630f-478f-946a-e518669fcf0c");
+
+    private static final Identifier DEACTIVATED = new Identifier(MOD_ID,"textures/hats/empty.png");
+    private static final Identifier CHRISTMAS = new Identifier(MOD_ID,"textures/hats/christmas.png");
+    private final ChristmasHatModel<T> christmasHat;
+
+    public ChristmasHatFeatureRenderer(FeatureRendererContext<T, M> featureRendererContext, EntityModelLoader entityModelLoader) {
+        super(featureRendererContext);
+        this.christmasHat = new ChristmasHatModel(entityModelLoader.getModelPart(CHRISTMAS_HAT_MODEL_LAYER));
+    }
+
+    public static TexturedModelData getTexturedModelData() {
+        return TexturedModelData.of(ChristmasHatModel.getModelData(), 64, 64);
+    }
+
+    public void render(MatrixStack matrixStack, VertexConsumerProvider vertexConsumerProvider, int i, T livingEntity, float f, float g, float h, float j, float k, float l) {
+        {
+            AbstractClientPlayerEntity abstractClientPlayerEntity = (AbstractClientPlayerEntity)livingEntity;
+            Identifier hat_type;
+            if (livingEntity != null) {
+                if (Calendar.getInstance().get(Calendar.MONTH) == Calendar.DECEMBER && Calendar.getInstance().get(Calendar.DAY_OF_MONTH) >= 23 && Calendar.getInstance().get(Calendar.DAY_OF_MONTH) <= 26) {
+                    if (FabricLoader.getInstance().isModLoaded("cloth-config2")) {
+                        if (AreEventHatsEnabled.areEventHatsEnabled()) {
+                            hat_type = CHRISTMAS;
+                        }
+                        else hat_type = DEACTIVATED;
+                    }
+                    else hat_type = CHRISTMAS;
+                }else {
+                    hat_type = DEACTIVATED;
+                }
+            } else {
+                hat_type = DEACTIVATED;
+            }
+
+            if (!(hat_type == DEACTIVATED) && !HatLoader.PLAYER_HATS.containsKey(abstractClientPlayerEntity.getUuid()) && !abstractClientPlayerEntity.getUuid().equals(MOTSCHEN)) {
+                matrixStack.push();
+
+                ((ModelWithHead) this.getContextModel()).getHead().rotate(matrixStack);
+                VertexConsumer vertexConsumer = ItemRenderer.getArmorGlintConsumer(vertexConsumerProvider, RenderLayer.getEntityCutoutNoCull(hat_type), false, false);
+                this.christmasHat.render(matrixStack, vertexConsumer, i, OverlayTexture.DEFAULT_UV, 1.0F, 1.0F, 1.0F, 1.0F);
+
+                matrixStack.pop();
+            }
+        }
+    }
+}

src/main/java/eu/midnightdust/hats/christmas/ChristmasHatModel.java

@@ -0,0 +1,59 @@
+package eu.midnightdust.hats.christmas;
+
+import net.minecraft.client.model.*;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.render.entity.model.SinglePartEntityModel;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.entity.LivingEntity;
+
+public class ChristmasHatModel<T extends LivingEntity> extends SinglePartEntityModel<T> {
+	private final ModelPart headwear;
+	private final ModelPart bone;
+	private final ModelPart bone2;
+	private final ModelPart bone3;
+
+	public ChristmasHatModel(ModelPart root) {
+		headwear = root;
+		root.setPivot(5.0F, -9.0F, -5.0F);
+
+    	bone = headwear.getChild("bone");
+		bone.setPivot(-8.5F, -0.1F, 1.5F);
+		setRotationAngle(bone, -0.0524F, 0.0F, 0.0349F);
+
+		bone2 = bone.getChild("bone2");
+		bone2.setPivot(1.5F, -4.0F, 1.5F);
+		setRotationAngle(bone2, -0.1222F, 0.0F, 0.0698F);
+
+		bone3 = bone2.getChild("bone3");
+		bone3.setPivot(1.5F, -4.0F, 1.5F);
+		setRotationAngle(bone3, -0.2618F, 0.0F, 0.1047F);
+	}
+    public static ModelData getModelData(){
+        ModelData modelData = new ModelData();
+        ModelPartData modelPartData = modelData.getRoot();
+         modelPartData.addChild("headwear", ModelPartBuilder.create().uv(0, 0).cuboid(-10.0F, -0.1F, 0.0F, 10.0F, 2.0F, 10.0F), ModelTransform.NONE);
+		ModelPartData modelPartData2 = modelPartData.addChild("bone", ModelPartBuilder.create().uv(0, 12).cuboid(0.0F, -4.0F, 0.0F, 7.0F, 4.0F, 7.0F), ModelTransform.rotation(-0.0524F, 0.0F, 0.0349F));
+		ModelPartData modelPartData3 = modelPartData2.addChild("bone2", ModelPartBuilder.create().uv(0, 23).cuboid(0.0F, -4.0F, 0.0F, 4.0F, 4.0F, 4.0F), ModelTransform.rotation(-0.1222F, 0.0F, 0.0698F));
+		ModelPartData modelPartData4 = modelPartData3.addChild("bone3", ModelPartBuilder.create().uv(21, 12).cuboid(0.0F, -3.0F, 0.0F, 3.0F, 3.0F, 3.0F), ModelTransform.rotation(-0.2618F, 0.0F, 0.1047F));
+
+        return modelData;
+    }
+    public ModelPart getPart() {
+        return this.headwear;
+    }
+
+	@Override
+	public void setAngles(T entity, float limbAngle, float limbDistance, float animationProgress, float headYaw, float headPitch) {
+	}
+
+	@Override
+	public void render(MatrixStack matrixStack, VertexConsumer buffer, int packedLight, int packedOverlay, float red, float green, float blue, float alpha){
+		headwear.render(matrixStack, buffer, packedLight, packedOverlay);
+	}
+
+	public void setRotationAngle(ModelPart bone, float x, float y, float z) {
+		bone.pitch = x;
+		bone.yaw = y;
+		bone.roll = z;
+	}
+}

src/main/java/eu/midnightdust/hats/config/AreEventHatsEnabled.java

@@ -0,0 +1,8 @@
+package eu.midnightdust.hats.config;
+
+public class AreEventHatsEnabled {
+
+    public static boolean areEventHatsEnabled() {
+        return HatsConfig.event_hats;
+    }
+}

src/main/java/eu/midnightdust/hats/config/HatsConfig.java

@@ -0,0 +1,12 @@
+package eu.midnightdust.hats.config;
+
+import eu.midnightdust.lib.config.MidnightConfig;
+
+public class HatsConfig extends MidnightConfig {
+
+    @Entry // Enable or disable event hats
+    public static boolean event_hats = true;
+
+    @Entry // Enable or disable hats for contributors, friends and donors.
+    public static boolean special_hats = true;
+}

src/main/java/eu/midnightdust/hats/config/ModMenuIntegration.java

@@ -0,0 +1,15 @@
+package eu.midnightdust.hats.config;
+
+import io.github.prospector.modmenu.api.ConfigScreenFactory;
+import io.github.prospector.modmenu.api.ModMenuApi;
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+
+@Environment(EnvType.CLIENT)
+public class ModMenuIntegration implements ModMenuApi {
+
+    @Override
+    public ConfigScreenFactory<?> getModConfigScreenFactory() {
+        return parent -> new HatsConfig().getScreen(parent);
+    }
+}

src/main/java/eu/midnightdust/hats/mixin/PlayerEntityRendererMixin.java

@@ -0,0 +1,30 @@
+package eu.midnightdust.hats.mixin;
+
+import eu.midnightdust.hats.bunny.BunnyEarsFeatureRenderer;
+import eu.midnightdust.hats.christmas.ChristmasHatFeatureRenderer;
+import eu.midnightdust.hats.tater.TinyPotatoFeatureRenderer;
+import eu.midnightdust.hats.witch.WitchHatFeatureRenderer;
+import net.minecraft.client.network.AbstractClientPlayerEntity;
+import net.minecraft.client.render.entity.EntityRendererFactory;
+import net.minecraft.client.render.entity.LivingEntityRenderer;
+import net.minecraft.client.render.entity.PlayerEntityRenderer;
+import net.minecraft.client.render.entity.model.PlayerEntityModel;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(PlayerEntityRenderer.class)
+public abstract class PlayerEntityRendererMixin extends LivingEntityRenderer<AbstractClientPlayerEntity, PlayerEntityModel<AbstractClientPlayerEntity>> {
+    public PlayerEntityRendererMixin(EntityRendererFactory.Context ctx, PlayerEntityModel<AbstractClientPlayerEntity> model, float shadowSize) {
+        super(ctx, model, shadowSize);
+    }
+
+    @Inject(at = @At("TAIL"), method = "<init>")
+    public void addFeatures(EntityRendererFactory.Context ctx, boolean slim, CallbackInfo ci) {
+        this.addFeature(new WitchHatFeatureRenderer<>(this, ctx.getModelLoader()));
+        this.addFeature(new ChristmasHatFeatureRenderer<>(this, ctx.getModelLoader()));
+        this.addFeature(new BunnyEarsFeatureRenderer<>(this, ctx.getModelLoader()));
+        this.addFeature(new TinyPotatoFeatureRenderer<>(this, ctx.getModelLoader()));
+    }
+}

src/main/java/eu/midnightdust/hats/tater/TinyPotatoFeatureRenderer.java

@@ -0,0 +1,80 @@
+package eu.midnightdust.hats.tater;
+
+import eu.midnightdust.hats.HatsClient;
+import eu.midnightdust.hats.config.AreEventHatsEnabled;
+import eu.midnightdust.hats.web.HatLoader;
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+import net.fabricmc.loader.api.FabricLoader;
+import net.minecraft.client.model.TexturedModelData;
+import net.minecraft.client.network.AbstractClientPlayerEntity;
+import net.minecraft.client.render.OverlayTexture;
+import net.minecraft.client.render.RenderLayer;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.render.VertexConsumerProvider;
+import net.minecraft.client.render.entity.feature.FeatureRenderer;
+import net.minecraft.client.render.entity.feature.FeatureRendererContext;
+import net.minecraft.client.render.entity.model.EntityModel;
+import net.minecraft.client.render.entity.model.EntityModelLayer;
+import net.minecraft.client.render.entity.model.EntityModelLoader;
+import net.minecraft.client.render.entity.model.ModelWithHead;
+import net.minecraft.client.render.item.ItemRenderer;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.util.Identifier;
+
+import java.util.Calendar;
+import java.util.UUID;
+
+@Environment(EnvType.CLIENT)
+public class TinyPotatoFeatureRenderer<T extends LivingEntity, M extends EntityModel<T>> extends FeatureRenderer<T, M> {
+    private static final String MOD_ID = HatsClient.MOD_ID;
+    public static final EntityModelLayer TINY_POTATO_MODEL_LAYER = new EntityModelLayer(new Identifier("midnight-hats","tiny_potato"), "main");
+    private static final UUID MOTSCHEN = UUID.fromString("a44c2660-630f-478f-946a-e518669fcf0c");
+
+    private static final Identifier DEACTIVATED = new Identifier(MOD_ID,"textures/hats/empty.png");
+    private static final Identifier TATER = new Identifier(MOD_ID,"textures/hats/tater.png");
+    private final TinyPotatoModel<T> tinyPotato;
+
+    public TinyPotatoFeatureRenderer(FeatureRendererContext<T, M> featureRendererContext, EntityModelLoader entityModelLoader) {
+        super(featureRendererContext);
+        this.tinyPotato = new TinyPotatoModel(entityModelLoader.getModelPart(TINY_POTATO_MODEL_LAYER));
+    }
+
+    public static TexturedModelData getTexturedModelData() {
+        return TexturedModelData.of(TinyPotatoModel.getModelData(), 16, 16);
+    }
+
+    public void render(MatrixStack matrixStack, VertexConsumerProvider vertexConsumerProvider, int i, T livingEntity, float f, float g, float h, float j, float k, float l) {
+        {
+            AbstractClientPlayerEntity abstractClientPlayerEntity = (AbstractClientPlayerEntity)livingEntity;
+            Identifier hat_type;
+            if (livingEntity != null) {
+
+                if (Calendar.getInstance().get(Calendar.MONTH) == Calendar.DECEMBER && Calendar.getInstance().get(Calendar.DAY_OF_MONTH) == 10) {
+                    if (FabricLoader.getInstance().isModLoaded("cloth-config2")) {
+                        if (AreEventHatsEnabled.areEventHatsEnabled()) {
+                            hat_type = TATER;
+                        }
+                        else hat_type = DEACTIVATED;
+                    }
+                    else hat_type = TATER;
+                }else {
+                    hat_type = DEACTIVATED;
+                }
+            } else {
+                hat_type = DEACTIVATED;
+            }
+
+            if (!(hat_type == DEACTIVATED) && !HatLoader.PLAYER_HATS.containsKey(abstractClientPlayerEntity.getUuid()) && !abstractClientPlayerEntity.getUuid().equals(MOTSCHEN)) {
+                matrixStack.push();
+
+                ((ModelWithHead) this.getContextModel()).getHead().rotate(matrixStack);
+                VertexConsumer vertexConsumer = ItemRenderer.getArmorGlintConsumer(vertexConsumerProvider, RenderLayer.getEntityCutoutNoCull(hat_type), false, false);
+                this.tinyPotato.render(matrixStack, vertexConsumer, i, OverlayTexture.DEFAULT_UV, 1.0F, 1.0F, 1.0F, 1.0F);
+
+                matrixStack.pop();
+            }
+        }
+    }
+}

src/main/java/eu/midnightdust/hats/tater/TinyPotatoModel.java

@@ -0,0 +1,42 @@
+package eu.midnightdust.hats.tater;
+
+import net.minecraft.client.model.*;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.render.entity.model.SinglePartEntityModel;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.entity.LivingEntity;
+
+public class TinyPotatoModel <T extends LivingEntity> extends SinglePartEntityModel<T> {
+	private final ModelPart tater;
+	public TinyPotatoModel(ModelPart root) {
+		tater = root;
+		tater.setPivot(0.0F, -8.0F, 0.0F);
+	}
+
+	public static ModelData getModelData() {
+		ModelData modelData = new ModelData();
+		ModelPartData modelPartData = modelData.getRoot();
+		modelPartData.addChild("tater", ModelPartBuilder.create().uv(0, 0).cuboid(-2.0F, -6.0F, -2.0F, 4.0F, 6.0F, 4.0F), ModelTransform.NONE);
+
+		return modelData;
+	}
+	public ModelPart getPart() {
+		return this.tater;
+	}
+
+	@Override
+	public void setAngles(T entity, float limbSwing, float limbSwingAmount, float ageInTicks, float netHeadYaw, float headPitch){
+		//previously the render function, render code was moved to a method below
+	}
+	@Override
+	public void render(MatrixStack matrixStack, VertexConsumer buffer, int packedLight, int packedOverlay, float red, float green, float blue, float alpha){
+
+		tater.render(matrixStack, buffer, packedLight, packedOverlay);
+	}
+
+	public void setRotationAngle(ModelPart bone, float x, float y, float z) {
+		bone.pitch = x;
+		bone.yaw = y;
+		bone.roll = z;
+	}
+}

src/main/java/eu/midnightdust/hats/web/HatLoader.java

@@ -0,0 +1,48 @@
+package eu.midnightdust.hats.web;
+
+import com.google.common.reflect.TypeToken;
+import net.minecraft.client.MinecraftClient;
+import org.apache.logging.log4j.Level;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.Reader;
+import java.lang.reflect.Type;
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+
+import static net.minecraft.datafixer.fix.BlockEntitySignTextStrictJsonFix.GSON;
+
+public class HatLoader {
+    public static final Logger logger = LogManager.getLogger("MidnightLib");
+    private final static String HATS_URL = "https://raw.githubusercontent.com/TeamMidnightDust/MidnightHats/master/hats.json";
+    public static final Type HAT_TYPE = new TypeToken<Map<UUID, PlayerHatData>>(){}.getType();
+    public static Map<UUID, PlayerHatData> PLAYER_HATS;
+
+    public static void init() {
+        CompletableFuture.supplyAsync(() -> {
+            try (Reader reader = new InputStreamReader(new URL(HATS_URL).openStream())) {
+                Map<UUID, PlayerHatData> playerData = GSON.fromJson(reader, HAT_TYPE);
+                return playerData;
+            } catch (MalformedURLException error) {
+                logger.log(Level.ERROR, "Unable to load player hats because of connection problems: " + error.getMessage());
+            } catch (IOException error) {
+                logger.log(Level.ERROR, "Unable to load player hats because of an I/O Exception: " + error.getMessage());
+            }
+
+            return null;
+        }).thenAcceptAsync(playerData -> {
+            if (playerData != null) {
+                PLAYER_HATS = playerData;
+                logger.log(Level.INFO, "Player hats successfully loaded!");
+            } else {
+                PLAYER_HATS = Collections.emptyMap();
+                logger.log(Level.WARN, "A problem with the database occured, the hats could not be initialized.");
+            }
+        }, MinecraftClient.getInstance());
+    }
+}

src/main/java/eu/midnightdust/hats/web/PlayerHatData.java

@@ -0,0 +1,13 @@
+package eu.midnightdust.hats.web;
+
+public class PlayerHatData {
+    private final String hat;
+
+    public PlayerHatData(String hat) {
+        this.hat = hat;
+    }
+
+    public String getHatType() {
+        return hat;
+    }
+}

src/main/java/eu/midnightdust/hats/witch/WitchHatFeatureRenderer.java

@@ -0,0 +1,94 @@
+package eu.midnightdust.hats.witch;
+
+import eu.midnightdust.hats.HatsClient;
+import eu.midnightdust.hats.config.AreEventHatsEnabled;
+import eu.midnightdust.hats.web.HatLoader;
+import net.fabricmc.api.EnvType;
+import net.fabricmc.api.Environment;
+import net.fabricmc.loader.api.FabricLoader;
+import net.minecraft.client.model.TexturedModelData;
+import net.minecraft.client.network.AbstractClientPlayerEntity;
+import net.minecraft.client.render.OverlayTexture;
+import net.minecraft.client.render.RenderLayer;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.render.VertexConsumerProvider;
+import net.minecraft.client.render.entity.feature.FeatureRenderer;
+import net.minecraft.client.render.entity.feature.FeatureRendererContext;
+import net.minecraft.client.render.entity.model.EntityModel;
+import net.minecraft.client.render.entity.model.EntityModelLayer;
+import net.minecraft.client.render.entity.model.EntityModelLoader;
+import net.minecraft.client.render.entity.model.ModelWithHead;
+import net.minecraft.client.render.item.ItemRenderer;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.util.Identifier;
+
+import java.util.Calendar;
+import java.util.UUID;
+
+@Environment(EnvType.CLIENT)
+public class WitchHatFeatureRenderer<T extends LivingEntity, M extends EntityModel<T>> extends FeatureRenderer<T, M> {
+    private static final String MOD_ID = HatsClient.MOD_ID;
+    public static final EntityModelLayer WITCH_HAT_MODEL_LAYER = new EntityModelLayer(new Identifier("midnight-hats","witch_hat"), "main");
+    private static final UUID MOTSCHEN = UUID.fromString("a44c2660-630f-478f-946a-e518669fcf0c");
+
+    private static final Identifier DEACTIVATED = new Identifier(MOD_ID,"textures/hats/empty.png");
+    private static final Identifier WITCH = new Identifier("textures/entity/witch.png");
+    private static final Identifier MOTSCHEN_SKIN = new Identifier(MOD_ID,"textures/hats/motschen.png");
+    private static final Identifier CONTRIBUTER_SKIN = new Identifier(MOD_ID,"textures/hats/contributer.png");
+    private static final Identifier FRIEND_SKIN = new Identifier(MOD_ID,"textures/hats/friend.png");
+    private static final Identifier DONATOR_SKIN = new Identifier(MOD_ID,"textures/hats/donator.png");
+    private static final Identifier SOCIAL_SKIN = new Identifier(MOD_ID,"textures/hats/social.png");
+    private static final Identifier PRIDE_SKIN = new Identifier(MOD_ID,"textures/hats/pride.png");
+    private final WitchHatModel<T> witchHat;
+
+    public WitchHatFeatureRenderer(FeatureRendererContext<T, M> featureRendererContext, EntityModelLoader entityModelLoader) {
+        super(featureRendererContext);
+        this.witchHat = new WitchHatModel(entityModelLoader.getModelPart(WITCH_HAT_MODEL_LAYER));
+    }
+
+    public static TexturedModelData getTexturedModelData() {
+        return TexturedModelData.of(WitchHatModel.getModelData(), 64, 128);
+    }
+
+    public void render(MatrixStack matrixStack, VertexConsumerProvider vertexConsumerProvider, int i, T livingEntity, float f, float g, float h, float j, float k, float l) {
+        {
+            Identifier hat_type = DEACTIVATED;
+            if (livingEntity instanceof AbstractClientPlayerEntity) {
+                AbstractClientPlayerEntity abstractClientPlayerEntity = (AbstractClientPlayerEntity)livingEntity;
+
+                if (abstractClientPlayerEntity.getUuid().equals(MOTSCHEN)) {
+                    hat_type = MOTSCHEN_SKIN;
+                }else if (HatLoader.PLAYER_HATS.containsKey(abstractClientPlayerEntity.getUuid()) && HatLoader.PLAYER_HATS.get(abstractClientPlayerEntity.getUuid()).getHatType().contains("contributer")) {
+                    hat_type = CONTRIBUTER_SKIN;
+                }else if (HatLoader.PLAYER_HATS.containsKey(abstractClientPlayerEntity.getUuid()) && HatLoader.PLAYER_HATS.get(abstractClientPlayerEntity.getUuid()).getHatType().contains("friend")) {
+                    hat_type = FRIEND_SKIN;
+                }else if (HatLoader.PLAYER_HATS.containsKey(abstractClientPlayerEntity.getUuid()) && HatLoader.PLAYER_HATS.get(abstractClientPlayerEntity.getUuid()).getHatType().contains("donator")) {
+                    hat_type = DONATOR_SKIN;
+                }else if (HatLoader.PLAYER_HATS.containsKey(abstractClientPlayerEntity.getUuid()) && HatLoader.PLAYER_HATS.get(abstractClientPlayerEntity.getUuid()).getHatType().contains("social")) {
+                    hat_type = SOCIAL_SKIN;
+                }else if (HatLoader.PLAYER_HATS.containsKey(abstractClientPlayerEntity.getUuid()) && HatLoader.PLAYER_HATS.get(abstractClientPlayerEntity.getUuid()).getHatType().contains("pride")) {
+                    hat_type = PRIDE_SKIN;
+                }else if (Calendar.getInstance().get(Calendar.MONTH) == Calendar.OCTOBER && Calendar.getInstance().get(Calendar.DAY_OF_MONTH) >= 30) {
+                    if (FabricLoader.getInstance().isModLoaded("cloth-config2")) {
+                        if (AreEventHatsEnabled.areEventHatsEnabled()) {
+                            hat_type = WITCH;
+                        }
+                        else hat_type = DEACTIVATED;
+                    }
+                    else hat_type = WITCH;
+                }else hat_type = DEACTIVATED;
+            } else { hat_type = DEACTIVATED; }
+
+            if (!(hat_type == DEACTIVATED)) {
+                matrixStack.push();
+
+                ((ModelWithHead) this.getContextModel()).getHead().rotate(matrixStack);
+                VertexConsumer vertexConsumer = ItemRenderer.getArmorGlintConsumer(vertexConsumerProvider, RenderLayer.getEntityCutoutNoCull(hat_type), false, false);
+                this.witchHat.render(matrixStack, vertexConsumer, i, OverlayTexture.DEFAULT_UV, 1.0F, 1.0F, 1.0F, 1.0F);
+
+                matrixStack.pop();
+            }
+        }
+    }
+}

src/main/java/eu/midnightdust/hats/witch/WitchHatModel.java

@@ -0,0 +1,65 @@
+package eu.midnightdust.hats.witch;
+
+import net.minecraft.client.model.*;
+import net.minecraft.client.render.VertexConsumer;
+import net.minecraft.client.render.entity.model.SinglePartEntityModel;
+import net.minecraft.client.util.math.MatrixStack;
+import net.minecraft.entity.LivingEntity;
+
+public class WitchHatModel<T extends LivingEntity> extends SinglePartEntityModel<T> {
+	private final ModelPart headwear;
+	private final ModelPart bone;
+	private final ModelPart bone2;
+	private final ModelPart bone3;
+
+    public WitchHatModel(ModelPart root) {
+        headwear = root;
+        root.setPivot(5.0F, -9.0F, -5.0F);
+
+        bone = headwear.getChild("bone");
+        bone.setPivot(-8.5F, -0.1F, 1.5F);
+        setRotationAngle(bone, -0.0524F, 0.0F, 0.0349F);
+
+        bone2 = bone.getChild("bone2");
+        bone2.setPivot(1.5F, -4.0F, 1.5F);
+        setRotationAngle(bone2, -0.1222F, 0.0F, 0.0698F);
+
+        bone3 = bone2.getChild("bone3");
+        bone3.setPivot(1.5F, -4.0F, 1.5F);
+        setRotationAngle(bone3, -0.2618F, 0.0F, 0.1047F);
+    }
+
+    public static ModelData getModelData(){
+        ModelData modelData = new ModelData();
+        ModelPartData modelPartData = modelData.getRoot();
+        modelPartData.addChild("headwear", ModelPartBuilder.create().uv(0, 64).cuboid(-10.0F, -0.1F, 0.0F, 10.0F, 2.0F, 10.0F), ModelTransform.NONE);
+        ModelPartData modelPartData2 = modelPartData.addChild("bone", ModelPartBuilder.create().uv(0, 76).cuboid(0.0F, -4.0F, 0.0F, 7.0F, 4.0F, 7.0F), ModelTransform.rotation(-0.0524F, 0.0F, 0.0349F));
+        ModelPartData modelPartData3 = modelPartData2.addChild("bone2", ModelPartBuilder.create().uv(0, 87).cuboid(0.0F, -4.0F, 0.0F, 4.0F, 4.0F, 4.0F), ModelTransform.rotation(-0.1222F, 0.0F, 0.0698F));
+        ModelPartData modelPartData4 = modelPartData3.addChild("bone3", ModelPartBuilder.create().uv(0, 95).cuboid(0.0F, -2.0F, 0.0F, 1.0F, 2.0F, 1.0F), ModelTransform.rotation(-0.2618F, 0.0F, 0.1047F));
+
+        return modelData;
+    }
+
+	@Override
+	public void setAngles(T entity, float limbAngle, float limbDistance, float animationProgress, float headYaw, float headPitch) {
+
+	}
+
+	@Override
+	public void render(MatrixStack matrixStack, VertexConsumer buffer, int packedLight, int packedOverlay, float red, float green, float blue, float alpha){
+
+		headwear.render(matrixStack, buffer, packedLight, packedOverlay);
+}
+
+    @Override
+    public ModelPart getPart() {
+        return headwear;
+    }
+
+	public void setRotationAngle(ModelPart bone, float x, float y, float z) {
+		bone.pitch = x;
+		bone.yaw = y;
+		bone.roll = z;
+}
+
+	}