diff --git a/Minecraft.Client/ArmorStandArmorModel.cpp b/Minecraft.Client/ArmorStandArmorModel.cpp
index 9fe22535..09761770 100644
--- a/Minecraft.Client/ArmorStandArmorModel.cpp
+++ b/Minecraft.Client/ArmorStandArmorModel.cpp
@@ -32,7 +32,7 @@ void ArmorStandArmorModel::setupAnim(float time, float r, float bob,
     Rotations ll = stand->getLeftLegPose();
     Rotations rl = stand->getRightLegPose();
 
-   
+  
     head->xRot = DEG_TO_RAD * h.getX();
     head->yRot = DEG_TO_RAD * h.getY();
     head->zRot = DEG_TO_RAD * h.getZ();
diff --git a/Minecraft.Client/ArmorStandRenderer.cpp b/Minecraft.Client/ArmorStandRenderer.cpp
index 03b53b4d..96337d92 100644
--- a/Minecraft.Client/ArmorStandRenderer.cpp
+++ b/Minecraft.Client/ArmorStandRenderer.cpp
@@ -1,27 +1,29 @@
 #include "stdafx.h"
+#include "HumanoidMobRenderer.h"
 #include "ArmorStandRenderer.h"
-#include "ArmorStandModel.h"
 #include "ArmorStandArmorModel.h"
 #include "HumanoidModel.h"
-#include "ItemInHandLayer.h"
+#include "ArmorStandModel.h"
 #include "CustomHeadLayer.h"
 #include "Textures.h"
-#include "HumanoidMobRenderer.h"
 #include "../Minecraft.World/ArmorStand.h"
 #include "../Minecraft.World/ArmorItem.h"
+#include "../Minecraft.World/Tile.h"
+#include "../Minecraft.World/Facing.h"
+#include <cmath>
+#include "EntityRenderDispatcher.h"
+#include "SkullTileRenderer.h"
+#include "PlayerRenderer.h"
+#include "../Minecraft.World/SkullItem.h"
+#include "../Minecraft.World/SkullTileEntity.h"
 
 static const float DEG_TO_RAD = 3.14159265f / 180.0f;
 
-ResourceLocation ArmorStandRenderer::LOC_ARMOR_STAND =
-    ResourceLocation(TN_MOB_ARMORSTAND);
+ResourceLocation ArmorStandRenderer::LOC_ARMOR_STAND = ResourceLocation(TN_MOB_ARMORSTAND);
 
-
-
-ArmorStandRenderer::ArmorStandArmorLayer::ArmorStandArmorLayer(
-    LivingEntityRenderer* renderer)
+ArmorStandRenderer::ArmorStandArmorLayer::ArmorStandArmorLayer(LivingEntityRenderer* renderer)
     : HumanoidArmorLayer(renderer)
 {
-  
     delete armorModel1;
     delete armorModel2;
     armorModel1 = new ArmorStandArmorModel(0.5f);
@@ -36,26 +38,18 @@ void ArmorStandRenderer::ArmorStandArmorLayer::createArmorModels()
     armorModel2 = new ArmorStandArmorModel(1.0f);
 }
 
-
-
 ArmorStandRenderer::ArmorStandRenderer()
     : LivingEntityRenderer(new ArmorStandModel(0.0f), 0.0f)
 {
-    
-    addLayer(new ArmorStandArmorLayer(this));
+    armorLayer = new ArmorStandArmorLayer(this);
 
-  
-    addLayer(new ItemInHandLayer(this));
-
-    
     ArmorStandModel* m = static_cast<ArmorStandModel*>(getModel());
-    addLayer(new CustomHeadLayer(m->head));
+    
+    
+    headLayer = m ? new CustomHeadLayer(m->head, this) : nullptr;
 }
 
-ArmorStandRenderer::~ArmorStandRenderer()
-{
-    
-}
+ArmorStandRenderer::~ArmorStandRenderer() {}
 
 ResourceLocation* ArmorStandRenderer::getTextureLocation(shared_ptr<Entity> entity)
 {
@@ -64,29 +58,39 @@ ResourceLocation* ArmorStandRenderer::getTextureLocation(shared_ptr<Entity> enti
 
 bool ArmorStandRenderer::shouldShowName(shared_ptr<LivingEntity> entity)
 {
-    
     if (!entity) return false;
     return entity->isCustomNameVisible();
 }
 
 void ArmorStandRenderer::setupRotations(shared_ptr<LivingEntity> mob,
-                                         float bob, float bodyRot, float a)
+                                        float bob, float bodyRot, float a)
 {
-    
+    shared_ptr<ArmorStand> stand = dynamic_pointer_cast<ArmorStand>(mob);
     glRotatef(180.0f - bodyRot, 0.0f, 1.0f, 0.0f);
+
+    if (stand)
+    {
+        long long ticksSinceHit = (long long)stand->tickCount - stand->lastHit;
+        if (ticksSinceHit >= 0 && ticksSinceHit < 5)
+        {
+            float wobble = (float)(ticksSinceHit + a) / 5.0f;
+            float angle  = (float)stand->hurtDir * sinf(wobble * 3.14159265f) * 3.0f;
+            glRotatef(angle, 0.0f, 0.0f, 1.0f);
+        }
+    }
 }
 
 void ArmorStandRenderer::render(shared_ptr<Entity> entity,
-                                 double x, double y, double z,
-                                 float rot, float a)
+                                double x, double y, double z,
+                                float rot, float a)
 {
     LivingEntityRenderer::render(entity, x, y, z, rot, a);
 }
 
 void ArmorStandRenderer::renderModel(shared_ptr<LivingEntity> mob,
-                                      float wp, float ws, float bob,
-                                      float headRotMinusBodyRot,
-                                      float headRotx, float scale)
+                                     float wp, float ws, float bob,
+                                     float headRotMinusBodyRot,
+                                     float headRotx, float scale)
 {
     shared_ptr<ArmorStand> stand = dynamic_pointer_cast<ArmorStand>(mob);
     if (!stand) return;
@@ -94,7 +98,6 @@ void ArmorStandRenderer::renderModel(shared_ptr<LivingEntity> mob,
     ArmorStandModel* m = static_cast<ArmorStandModel*>(getModel());
     if (!m) return;
 
-   
     Rotations h  = stand->getHeadPose();
     Rotations b  = stand->getBodyPose();
     Rotations la = stand->getLeftArmPose();
@@ -102,120 +105,111 @@ void ArmorStandRenderer::renderModel(shared_ptr<LivingEntity> mob,
     Rotations ll = stand->getLeftLegPose();
     Rotations rl = stand->getRightLegPose();
 
-    
     m->setupPose(
-        h.getX()  * DEG_TO_RAD,  h.getY()  * DEG_TO_RAD,  h.getZ()  * DEG_TO_RAD,
-        b.getX()  * DEG_TO_RAD,  b.getY()  * DEG_TO_RAD,  b.getZ()  * DEG_TO_RAD,
-        la.getX() * DEG_TO_RAD,  la.getY() * DEG_TO_RAD,  la.getZ() * DEG_TO_RAD,
-        ra.getX() * DEG_TO_RAD,  ra.getY() * DEG_TO_RAD,  ra.getZ() * DEG_TO_RAD,
-        ll.getX() * DEG_TO_RAD,  ll.getY() * DEG_TO_RAD,  ll.getZ() * DEG_TO_RAD,
-        rl.getX() * DEG_TO_RAD,  rl.getY() * DEG_TO_RAD,  rl.getZ() * DEG_TO_RAD
+        h.x  * DEG_TO_RAD, h.y  * DEG_TO_RAD, h.z  * DEG_TO_RAD,
+        b.x  * DEG_TO_RAD, b.y  * DEG_TO_RAD, b.z  * DEG_TO_RAD,
+        la.x * DEG_TO_RAD, la.y * DEG_TO_RAD, la.z * DEG_TO_RAD,
+        ra.x * DEG_TO_RAD, ra.y * DEG_TO_RAD, ra.z * DEG_TO_RAD,
+        ll.x * DEG_TO_RAD, ll.y * DEG_TO_RAD, ll.z * DEG_TO_RAD,
+        rl.x * DEG_TO_RAD, rl.y * DEG_TO_RAD, rl.z * DEG_TO_RAD
     );
-
     
-    ArmorStandArmorLayer* al = getArmorLayer();
-
-    if (al)
+    if (armorLayer)
     {
         auto applyPose = [&](HumanoidModel* am)
         {
             if (!am) return;
-
-            
-            am->head->xRot = h.getX() * DEG_TO_RAD;
-            am->head->yRot = h.getY() * DEG_TO_RAD;
-            am->head->zRot = h.getZ() * DEG_TO_RAD;
-            if (am->hair) {
-                am->hair->xRot = h.getX() * DEG_TO_RAD;
-                am->hair->yRot = h.getY() * DEG_TO_RAD;
-                am->hair->zRot = h.getZ() * DEG_TO_RAD;
+            am->head->xRot = h.x  * DEG_TO_RAD;
+            am->head->yRot = h.y  * DEG_TO_RAD;
+            am->head->zRot = h.z  * DEG_TO_RAD;
+            if (am->hair)
+            {
+                am->hair->xRot = h.x * DEG_TO_RAD;
+                am->hair->yRot = h.y * DEG_TO_RAD;
+                am->hair->zRot = h.z * DEG_TO_RAD;
             }
-
-           
-            am->body->xRot = b.getX() * DEG_TO_RAD;
-            am->body->yRot = b.getY() * DEG_TO_RAD;
-            am->body->zRot = b.getZ() * DEG_TO_RAD;
-
-           
-            am->arm1->xRot = la.getX() * DEG_TO_RAD;
-            am->arm1->yRot = la.getY() * DEG_TO_RAD;
-            am->arm1->zRot = la.getZ() * DEG_TO_RAD;
-
-           
-            am->arm0->xRot = ra.getX() * DEG_TO_RAD;
-            am->arm0->yRot = ra.getY() * DEG_TO_RAD;
-            am->arm0->zRot = ra.getZ() * DEG_TO_RAD;
-
-           
-            am->leg0->xRot = rl.getX() * DEG_TO_RAD;
-            am->leg0->yRot = rl.getY() * DEG_TO_RAD;
-            am->leg0->zRot = rl.getZ() * DEG_TO_RAD;
-
-            
-            am->leg1->xRot = ll.getX() * DEG_TO_RAD;
-            am->leg1->yRot = ll.getY() * DEG_TO_RAD;
-            am->leg1->zRot = ll.getZ() * DEG_TO_RAD;
+            am->body->xRot = b.x  * DEG_TO_RAD;
+            am->body->yRot = b.y  * DEG_TO_RAD;
+            am->body->zRot = b.z  * DEG_TO_RAD;
+            am->arm1->xRot = la.x * DEG_TO_RAD;
+            am->arm1->yRot = la.y * DEG_TO_RAD;
+            am->arm1->zRot = la.z * DEG_TO_RAD;
+            am->arm0->xRot = ra.x * DEG_TO_RAD;
+            am->arm0->yRot = ra.y * DEG_TO_RAD;
+            am->arm0->zRot = ra.z * DEG_TO_RAD;
+            am->leg0->xRot = rl.x * DEG_TO_RAD;
+            am->leg0->yRot = rl.y * DEG_TO_RAD;
+            am->leg0->zRot = rl.z * DEG_TO_RAD;
+            am->leg1->xRot = ll.x * DEG_TO_RAD;
+            am->leg1->yRot = ll.y * DEG_TO_RAD;
+            am->leg1->zRot = ll.z * DEG_TO_RAD;
         };
 
-        applyPose(static_cast<HumanoidModel*>(al->armorModel1));
-        applyPose(static_cast<HumanoidModel*>(al->armorModel2));
+        applyPose(static_cast<HumanoidModel*>(armorLayer->armorModel1));
+        applyPose(static_cast<HumanoidModel*>(armorLayer->armorModel2));
     }
 
-    LivingEntityRenderer::renderModel(mob, wp, ws, bob,
-                                        headRotMinusBodyRot, headRotx, scale);
+    LivingEntityRenderer::renderModel(mob, wp, ws, bob, headRotMinusBodyRot, headRotx, scale);
 
-    for (size_t i = 0; i < renderLayers.size(); ++i) {
-        if (renderLayers[i]) {
-            renderLayers[i]->render(mob, wp, ws, bob, headRotMinusBodyRot, headRotx, scale, true);
-        }
+    
+    if (headLayer)
+    {
+        float fScale = 1.0f / 16.0f;
+        float bodyRot = mob->yBodyRotO + (mob->yBodyRot - mob->yBodyRotO) * 0.0f;
+        float headRot = mob->yHeadRotO + (mob->yHeadRot - mob->yHeadRotO) * 0.0f;
+        float headRotX = mob->xRotO    + (mob->xRot    - mob->xRotO)    * 0.0f;
+        headLayer->render(mob, wp, ws, bob, headRot - bodyRot, headRotX, fScale, true);
     }
 }
 
+
+void ArmorStandRenderer::additionalRendering(shared_ptr<LivingEntity> mob, float a)
+{
+    
+}
+
+
 int ArmorStandRenderer::prepareArmor(shared_ptr<LivingEntity> mob, int layer, float a)
 {
     if (!armorLayer) return -1;
 
     shared_ptr<ItemInstance> itemInstance = mob->getArmor(3 - layer);
-    if (itemInstance != nullptr)
+    if (!itemInstance) return -1;
+
+    Item* item = itemInstance->getItem();
+    if (!item) return -1;
+
+    ArmorItem* armorItem = dynamic_cast<ArmorItem*>(item);
+    if (!armorItem) return -1; 
+
+    bindTexture(HumanoidMobRenderer::getArmorLocation(armorItem, layer));
+
+    HumanoidModel* am = armorLayer->getArmorModel(layer);
+    if (!am) return -1;
+
+    am->head->visible = (layer == 0);
+    if (am->hair) am->hair->visible = (layer == 0);
+    am->body->visible = (layer == 1 || layer == 2);
+    am->arm0->visible = (layer == 1);
+    am->arm1->visible = (layer == 1);
+    am->leg0->visible = (layer == 2 || layer == 3);
+    am->leg1->visible = (layer == 2 || layer == 3);
+
+    setArmor(am);
+    am->attackTime = model->attackTime;
+    am->riding     = model->riding;
+    am->young      = mob->isBaby();
+
+    if (armorItem->getMaterial() == ArmorItem::ArmorMaterial::CLOTH)
     {
-        Item *item = itemInstance->getItem();
-        ArmorItem *armorItem = dynamic_cast<ArmorItem *>(item);
-        if (armorItem != nullptr)
-        {
-            bindTexture(HumanoidMobRenderer::getArmorLocation(armorItem, layer));
-
-            HumanoidModel *am = armorLayer->getArmorModel(layer);
-            
-            am->head->visible = (layer == 0);
-            if (am->hair) am->hair->visible = (layer == 0);
-            am->body->visible = (layer == 1 || layer == 2);
-            am->arm0->visible = (layer == 1);
-            am->arm1->visible = (layer == 1);
-            am->leg0->visible = (layer == 2 || layer == 3);
-            am->leg1->visible = (layer == 2 || layer == 3);
-
-            setArmor(am);
-            am->attackTime = model->attackTime;
-            am->riding = model->riding;
-            am->young = mob->isBaby();
-
-            if (armorItem->getMaterial() == ArmorItem::ArmorMaterial::CLOTH)
-            {
-                int color = armorItem->getColor(itemInstance);
-                float red   = static_cast<float>((color >> 16) & 0xFF) / 255.0f;
-                float green = static_cast<float>((color >> 8)  & 0xFF) / 255.0f;
-                float blue  = static_cast<float>(color & 0xFF)         / 255.0f;
-                glColor3f(red, green, blue);
-
-                if (itemInstance->isEnchanted()) return 0x1f;
-                return 0x10;
-            }
-
-            glColor3f(1.0f, 1.0f, 1.0f);
-            if (itemInstance->isEnchanted()) return 15;
-
-            return 1;
-        }
+        int   color = armorItem->getColor(itemInstance);
+        float red   = static_cast<float>((color >> 16) & 0xFF) / 255.0f;
+        float green = static_cast<float>((color >>  8) & 0xFF) / 255.0f;
+        float blue  = static_cast<float>( color        & 0xFF) / 255.0f;
+        glColor3f(red, green, blue);
+        return itemInstance->isEnchanted() ? 0x1f : 0x10;
     }
-    return -1;
+
+    glColor3f(1.0f, 1.0f, 1.0f);
+    return itemInstance->isEnchanted() ? 15 : 1;
 }
\ No newline at end of file
diff --git a/Minecraft.Client/ArmorStandRenderer.h b/Minecraft.Client/ArmorStandRenderer.h
index 827c5a66..9742f31e 100644
--- a/Minecraft.Client/ArmorStandRenderer.h
+++ b/Minecraft.Client/ArmorStandRenderer.h
@@ -2,13 +2,13 @@
 #include "LivingEntityRenderer.h"
 #include "HumanoidArmorLayer.h"
 #include "ResourceLocation.h"
-
 #include <vector>
 
 class ArmorStandModel;
 class LivingEntity;
 class Entity;
 class RenderLayer;
+class CustomHeadLayer;
 
 class ArmorStandRenderer : public LivingEntityRenderer {
 public:
@@ -22,17 +22,12 @@ public:
 protected:
     std::vector<RenderLayer*> renderLayers;
     ArmorStandArmorLayer*     armorLayer;
+    CustomHeadLayer*          headLayer;
 
 public:
-    void addLayer(RenderLayer* layer) {
-        renderLayers.push_back(layer);
-    }
-    void addLayer(ArmorStandArmorLayer* layer) {
-        armorLayer = layer;
-    }
-    ArmorStandArmorLayer* getArmorLayer() {
-        return armorLayer;
-    }
+    void addLayer(RenderLayer* layer)           { renderLayers.push_back(layer); }
+    void addLayer(ArmorStandArmorLayer* layer)  { armorLayer = layer; }
+    ArmorStandArmorLayer* getArmorLayer()       { return armorLayer; }
 
     static ResourceLocation LOC_ARMOR_STAND;
 
@@ -40,15 +35,17 @@ public:
     virtual ~ArmorStandRenderer();
 
     virtual ResourceLocation* getTextureLocation(shared_ptr<Entity> entity) override;
-    virtual bool              shouldShowName(shared_ptr<LivingEntity> mob) override;   
-    virtual void              setupRotations(shared_ptr<LivingEntity> mob,
-                                             float bob, float bodyRot, float a) override;
-    virtual void              render(shared_ptr<Entity> entity,
-                                     double x, double y, double z,
-                                     float rot, float a) override;
-    virtual void              renderModel(shared_ptr<LivingEntity> mob,
-                                          float wp, float ws, float bob,
-                                          float headRotMinusBodyRot,
-                                          float headRotx, float scale) override;
-    virtual int               prepareArmor(shared_ptr<LivingEntity> mob, int layer, float a) override;
+    virtual bool              shouldShowName(shared_ptr<LivingEntity> mob) override;
+
+    virtual void setupRotations(shared_ptr<LivingEntity> mob,
+                                float bob, float bodyRot, float a) override;
+    virtual void render(shared_ptr<Entity> entity,
+                        double x, double y, double z,
+                        float rot, float a) override;
+    virtual void renderModel(shared_ptr<LivingEntity> mob,
+                             float wp, float ws, float bob,
+                             float headRotMinusBodyRot,
+                             float headRotx, float scale) override;
+    virtual int  prepareArmor(shared_ptr<LivingEntity> mob, int layer, float a) override;
+    virtual void additionalRendering(shared_ptr<LivingEntity> mob, float a) override;
 };
\ No newline at end of file
diff --git a/Minecraft.Client/CustomHeadLayer.cpp b/Minecraft.Client/CustomHeadLayer.cpp
index a62cfca0..72f9955a 100644
--- a/Minecraft.Client/CustomHeadLayer.cpp
+++ b/Minecraft.Client/CustomHeadLayer.cpp
@@ -1,17 +1,27 @@
 #include "stdafx.h"
 #include "CustomHeadLayer.h"
+#include "LivingEntityRenderer.h"
 #include "ModelPart.h"
+#include "SkullTileRenderer.h"
+#include "TileRenderer.h"
+#include "EntityRenderDispatcher.h"
+#include "Minecraft.h"
 #include "../Minecraft.World/ItemInstance.h"
 #include "../Minecraft.World/Item.h"
 #include "../Minecraft.World/Tile.h"
+#include "../Minecraft.World/SkullItem.h"
+#include "../Minecraft.World/SkullTileEntity.h"
 #include "../Minecraft.World/LivingEntity.h"
+#include "../Minecraft.World/Facing.h"
 
-CustomHeadLayer::CustomHeadLayer(ModelPart* headPart)
-    : headPart(headPart)
+
+CustomHeadLayer::CustomHeadLayer(ModelPart* headPart, LivingEntityRenderer* parentRenderer)
+    : headPart(headPart), parentRenderer(parentRenderer)
 {
 }
 
-int CustomHeadLayer::colorsOnDamage() {
+int CustomHeadLayer::colorsOnDamage()
+{
     return 1;
 }
 
@@ -20,59 +30,74 @@ void CustomHeadLayer::render(shared_ptr<LivingEntity> mob,
                               float headRot, float headRotX,
                               float scale, bool useCompiled)
 {
- 
-    ItemInstanceArray slots = mob->getEquipmentSlots();
-    if (slots.length < 5) return;
-    shared_ptr<ItemInstance> helmet = slots[4];
+    shared_ptr<ItemInstance> helmet = mob->getArmor(3);
     if (!helmet) return;
 
     Item* item = helmet->getItem();
     if (!item) return;
 
-  
-    bool hasHatLayer = false;
-    if (mob->instanceof(eTYPE_PLAYER)) {
+    if (mob->instanceof(eTYPE_PLAYER))
+    {
         _SkinAdjustments adj;
         mob->getSkinAdjustments(&adj);
-       
-        hasHatLayer = (adj.data[0] & 0x100) != 0;
+        if ((adj.data[0] & 0x100) != 0) return;
     }
 
-   
+    bool isBaby  = mob->isBaby();
+    // FIX: Riconosciamo correttamente lo SkullItem invece dell'ID del Blocco
+    bool isSkull = (dynamic_cast<SkullItem*>(item) != nullptr);
 
     glPushMatrix();
+   
+    if (isBaby)
+        glTranslatef(0.0f, 0.2f, 0.0f);
 
-    
     headPart->translateTo(0.0625f);
     glColor4f(1.0f, 1.0f, 1.0f, 1.0f);
 
-    int itemId = item->id;  
-
-    if (itemId == Tile::skull_Id) {
-        
+    if (isSkull)
+    {
         glScalef(1.1875f, -1.1875f, -1.1875f);
-        if (hasHatLayer)
+
+        if (isBaby)
             glTranslatef(0.0f, 0.0625f, 0.0f);
 
-       
+        if (SkullTileRenderer::instance)
+        {
+            int     skullType = helmet->getAuxValue() & 0xF;
+            wstring extra     = L"";
+            if (helmet->hasTag() && helmet->getTag()->contains(L"SkullOwner"))
+                extra = helmet->getTag()->getString(L"SkullOwner");
 
-    } else if (itemId < 0x100) {
-        
+            SkullTileRenderer::instance->renderSkull(
+                //Skull on armor stand is slightly lowered
+                -0.5f, -0.05f, -0.5f,
+                Facing::UP,
+                180.0f,
+                skullType,
+                extra
+            );
+        }
+    }
+    else if (item->id < 256)
+    {
         glTranslatef(0.0f, -0.25f, 0.0f);
         glRotatef(180.0f, 0.0f, 1.0f, 0.0f);
         glScalef(0.625f, -0.625f, -0.625f);
 
-        if (hasHatLayer)
+        if (isBaby)
             glTranslatef(0.0f, 0.1875f, 0.0f);
 
         glRotatef(90.0f, 0.0f, 1.0f, 0.0f);
 
-        
-        if (itemId > 0 && itemId < Tile::TILE_NUM_COUNT && Tile::tiles[itemId]) {
-            
+        Minecraft* mc = Minecraft::GetInstance();
+        if (mc)
+        {
+            auto* iihr = mc->getItemInHandRenderer();
+            if (iihr)
+                iihr->renderItem(mob, helmet, 0, true);
         }
     }
 
-
     glPopMatrix();
 }
\ No newline at end of file
diff --git a/Minecraft.Client/CustomHeadLayer.h b/Minecraft.Client/CustomHeadLayer.h
index f4b83301..da6814c6 100644
--- a/Minecraft.Client/CustomHeadLayer.h
+++ b/Minecraft.Client/CustomHeadLayer.h
@@ -3,16 +3,17 @@
 
 class ModelPart;
 class LivingEntity;
+class LivingEntityRenderer;
 
 class CustomHeadLayer : public RenderLayer {
 public:
-    
-    ModelPart* headPart;
+    ModelPart*            headPart;
+    LivingEntityRenderer* parentRenderer;
 
-    explicit CustomHeadLayer(ModelPart* headPart);
+    CustomHeadLayer(ModelPart* headPart, LivingEntityRenderer* parentRenderer);
     virtual ~CustomHeadLayer() {}
 
-    virtual int  colorsOnDamage() override;   
+    virtual int  colorsOnDamage() override;
     virtual void render(shared_ptr<LivingEntity> mob,
                         float wp, float ws, float bob,
                         float headRot, float headRotX,
diff --git a/Minecraft.Client/EntityRenderer.h b/Minecraft.Client/EntityRenderer.h
index 0445fe1e..6cdb1d86 100644
--- a/Minecraft.Client/EntityRenderer.h
+++ b/Minecraft.Client/EntityRenderer.h
@@ -21,6 +21,7 @@ class Font;
 // 4J - this was originally a generic of type EntityRenderer<T extends Entity>
 class EntityRenderer
 {
+	friend class CustomHeadLayer;
 	friend class PlayerRenderer; // 4J Added to allow PlayerRenderer to call renderShadow
 protected:
 	EntityRenderDispatcher *entityRenderDispatcher;
diff --git a/Minecraft.Client/Minecraft.h b/Minecraft.Client/Minecraft.h
index 9425cf9f..0845edb3 100644
--- a/Minecraft.Client/Minecraft.h
+++ b/Minecraft.Client/Minecraft.h
@@ -79,6 +79,7 @@ private:
 	static void levelTickUpdateFunc(void* pParam);
 	static void levelTickThreadInitFunc();
 
+
 public:
 	int width, height;
 	int width_phys, height_phys; // 4J - added
@@ -122,7 +123,7 @@ public:
 	void storeExtraLocalPlayer(int idx);
 	void updatePlayerViewportAssignments();
 	int unoccupiedQuadrant;	// 4J - added
-
+	ItemInHandRenderer* getItemInHandRenderer() const { return localitemInHandRenderers[localPlayerIdx]; };
 	shared_ptr<LivingEntity> cameraTargetPlayer;
 	shared_ptr<LivingEntity> crosshairPickMob;
 	ParticleEngine *particleEngine;
diff --git a/Minecraft.Client/PlayerRenderer.cpp b/Minecraft.Client/PlayerRenderer.cpp
index d3dc4491..2d25f54d 100644
--- a/Minecraft.Client/PlayerRenderer.cpp
+++ b/Minecraft.Client/PlayerRenderer.cpp
@@ -48,12 +48,12 @@ static unsigned int nametagColorForIndex(int index)
 		float r = 0.f, g = 0.f, b = 0.f;
 		switch (i % 6)
 		{
-			case 0: r = 1.f; g = t;   b = 0.f; break;
-			case 1: r = q;   g = 1.f; b = 0.f; break;
-			case 2: r = 0.f; g = 1.f; b = t;   break;
-			case 3: r = 0.f; g = q;   b = 1.f; break;
-			case 4: r = t;   g = 0.f; b = 1.f; break;
-			default: r = 1.f; g = 0.f; b = q; break;
+		case 0: r = 1.f; g = t;   b = 0.f; break;
+		case 1: r = q;   g = 1.f; b = 0.f; break;
+		case 2: r = 0.f; g = 1.f; b = t;   break;
+		case 3: r = 0.f; g = q;   b = 1.f; break;
+		case 4: r = t;   g = 0.f; b = 1.f; break;
+		default: r = 1.f; g = 0.f; b = q; break;
 		}
 		int ri = (int)(r * 255.f) & 0xff, gi = (int)(g * 255.f) & 0xff, bi = (int)(b * 255.f) & 0xff;
 		return 0xff000000u | (ri << 16) | (gi << 8) | bi;
@@ -64,21 +64,21 @@ static unsigned int nametagColorForIndex(int index)
 
 ResourceLocation PlayerRenderer::DEFAULT_LOCATION = ResourceLocation(TN_MOB_CHAR);
 
-PlayerRenderer::PlayerRenderer() : LivingEntityRenderer( new HumanoidModel(0), 0.5f, true, true )
+PlayerRenderer::PlayerRenderer() : LivingEntityRenderer(new HumanoidModel(0), 0.5f, true, true)
 {
-	humanoidModel = static_cast<HumanoidModel *>(model);
-	humanoidModelSlim = static_cast<HumanoidModel *>(modelSlim);
-	newHumanoidModel = static_cast<HumanoidModel *>(newModel);
-	newHumanoidModelSlim = static_cast<HumanoidModel *>(newModelSlim);
+	humanoidModel = static_cast<HumanoidModel*>(model);
+	humanoidModelSlim = static_cast<HumanoidModel*>(modelSlim);
+	newHumanoidModel = static_cast<HumanoidModel*>(newModel);
+	newHumanoidModelSlim = static_cast<HumanoidModel*>(newModelSlim);
 
-    armorParts1 = new HumanoidModel(1.0f);
-    armorParts2 = new HumanoidModel(0.5f);
-    armorParts3 = new HumanoidModel(0.5f);
+	armorParts1 = new HumanoidModel(1.0f);
+	armorParts2 = new HumanoidModel(0.5f);
+	armorParts3 = new HumanoidModel(0.5f);
 }
 
 unsigned int PlayerRenderer::getNametagColour(int index)
 {
-	if( index >= 0 && index < MINECRAFT_NET_MAX_PLAYERS)
+	if (index >= 0 && index < MINECRAFT_NET_MAX_PLAYERS)
 		return nametagColorForIndex(index);
 	return 0xFF000000;
 }
@@ -89,33 +89,33 @@ int PlayerRenderer::prepareArmor(shared_ptr<LivingEntity> _player, int layer, fl
 	shared_ptr<Player> player = dynamic_pointer_cast<Player>(_player);
 
 	// 4J-PB - need to disable rendering armour for some special skins (Daleks)
-	unsigned int uiAnimOverrideBitmask=player->getAnimOverrideBitmask();
-	if(uiAnimOverrideBitmask&(1<<HumanoidModel::eAnim_DontRenderArmour))
+	unsigned int uiAnimOverrideBitmask = player->getAnimOverrideBitmask();
+	if (uiAnimOverrideBitmask & (1 << HumanoidModel::eAnim_DontRenderArmour))
 	{
 		return -1;
 	}
 
-    shared_ptr<ItemInstance> itemInstance = player->inventory->getArmor(3 - layer);
-    if (itemInstance != nullptr)
+	shared_ptr<ItemInstance> itemInstance = player->inventory->getArmor(3 - layer);
+	if (itemInstance != nullptr)
 	{
-        Item *item = itemInstance->getItem();
-        if (dynamic_cast<ArmorItem *>(item))
+		Item* item = itemInstance->getItem();
+		if (dynamic_cast<ArmorItem*>(item))
 		{
-            ArmorItem *armorItem = dynamic_cast<ArmorItem *>(item);
+			ArmorItem* armorItem = dynamic_cast<ArmorItem*>(item);
 			bindTexture(HumanoidMobRenderer::getArmorLocation(armorItem, layer));
 
 			SkullItem* skullItem = dynamic_cast<SkullItem*>(item);
-            HumanoidModel *armor = layer == 2 ? armorParts2 : armorParts1;
+			HumanoidModel* armor = layer == 2 ? armorParts2 : armorParts1;
 
-            armor->head->visible = layer == 0;
-            armor->hair->visible = layer == 0;
-            armor->body->visible = layer == 1 || layer == 2;
-            armor->arm0->visible = layer == 1;
-            armor->arm1->visible = layer == 1;
-            armor->leg0->visible = layer == 2 || layer == 3;
-            armor->leg1->visible = layer == 2 || layer == 3;
+			armor->head->visible = layer == 0;
+			armor->hair->visible = layer == 0;
+			armor->body->visible = layer == 1 || layer == 2;
+			armor->arm0->visible = layer == 1;
+			armor->arm1->visible = layer == 1;
+			armor->leg0->visible = layer == 2 || layer == 3;
+			armor->leg1->visible = layer == 2 || layer == 3;
 
-            setArmor(armor);
+			setArmor(armor);
 			if (armor != nullptr) armor->attackTime = model->attackTime;
 			if (armor != nullptr) armor->riding = model->riding;
 			if (armor != nullptr) armor->young = model->young;
@@ -139,25 +139,15 @@ int PlayerRenderer::prepareArmor(shared_ptr<LivingEntity> _player, int layer, fl
 
 			if (itemInstance->isEnchanted()) return 0xf;
 
-            return 1;
-        }
+			return 1;
+		}
 		else if (dynamic_cast<SkullItem*>(item)) {
 			SkullItem* skullItem = dynamic_cast<SkullItem*>(item);
-			HumanoidModel* armor = armorParts3;
-			auto t = new SkeletonHeadModel(0, 0, 64, 64, 1);
+			HumanoidModel* armor = armorParts1;
+			//auto t = new SkeletonHeadModel(0, 0, 64, 64, 1);
 			//armor->head->_init();
-			armor->head = t->head;
+			//armor->head = t->head;
 			//armor->head->addHumanoidBox(-4, -8, -4, 8, 8, 8, 0.5); // Head
-
-			armor->head->visible = layer == 0;
-
-			armor->hair->visible = false;
-			armor->body->visible = false;
-			armor->arm0->visible = false;
-			armor->arm1->visible = false;
-			armor->leg0->visible = false;
-			armor->leg1->visible = false;
-
 			switch (itemInstance->getAuxValue())
 			{
 			case SkullTileEntity::TYPE_WITHER:
@@ -171,6 +161,9 @@ int PlayerRenderer::prepareArmor(shared_ptr<LivingEntity> _player, int layer, fl
 				break;
 			case SkullTileEntity::TYPE_CHAR:
 			{
+				armor = armorParts3;
+				auto t = new SkeletonHeadModel(0, 0, 64, 64, 1);
+				armor->head = t->head;
 				bindTexture(&PlayerRenderer::DEFAULT_LOCATION);
 				break;
 			}
@@ -179,6 +172,14 @@ int PlayerRenderer::prepareArmor(shared_ptr<LivingEntity> _player, int layer, fl
 				bindTexture(&SKELETON_LOCATION);
 				break;
 			}
+			armor->head->visible = layer == 0;
+
+			armor->hair->visible = false;
+			armor->body->visible = false;
+			armor->arm0->visible = false;
+			armor->arm1->visible = false;
+			armor->leg0->visible = false;
+			armor->leg1->visible = false;
 			setArmor(armor);
 			if (armor != nullptr) armor->attackTime = model->attackTime;
 			if (armor != nullptr) armor->riding = model->riding;
@@ -186,8 +187,9 @@ int PlayerRenderer::prepareArmor(shared_ptr<LivingEntity> _player, int layer, fl
 
 			return 1;
 		}
-    }
-    return -1;
+
+	}
+	return -1;
 
 }
 
@@ -198,11 +200,11 @@ void PlayerRenderer::prepareSecondPassArmor(shared_ptr<LivingEntity> _player, in
 	shared_ptr<ItemInstance> itemInstance = player->inventory->getArmor(3 - layer);
 	if (itemInstance != nullptr)
 	{
-		Item *item = itemInstance->getItem();
-		if (dynamic_cast<ArmorItem *>(item))
+		Item* item = itemInstance->getItem();
+		if (dynamic_cast<ArmorItem*>(item))
 		{
-            ArmorItem *armorItem = dynamic_cast<ArmorItem *>(item);
-			bindTexture(HumanoidMobRenderer::getArmorLocation(static_cast<ArmorItem *>(item), layer, true));
+			ArmorItem* armorItem = dynamic_cast<ArmorItem*>(item);
+			bindTexture(HumanoidMobRenderer::getArmorLocation(static_cast<ArmorItem*>(item), layer, true));
 
 			float brightness = SharedConstants::TEXTURE_LIGHTING ? 1 : player->getBrightness(a);
 			glColor3f(brightness, brightness, brightness);
@@ -219,40 +221,40 @@ void PlayerRenderer::render(shared_ptr<Entity> _mob, double x, double y, double
 
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
 	shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
-	HumanoidModel *resModel = static_cast<HumanoidModel *>(model);
+	HumanoidModel* resModel = static_cast<HumanoidModel*>(model);
 
-	if(mob == nullptr) return;
-	if(mob->hasInvisiblePrivilege()) return;
+	if (mob == nullptr) return;
+	if (mob->hasInvisiblePrivilege()) return;
 
 	if (mob != nullptr)
 	{
-		Textures *textures = Minecraft::GetInstance()->textures;
+		Textures* textures = Minecraft::GetInstance()->textures;
 		int skinId = mob->getPlayerDefaultSkin() - 1;
 		int defaultSkin = mob->getPlayerDefaultSkin() + 35;
 
 		if (slim[skinId] == true)
 		{
 			if (textures->getHeight(mob->customTextureUrl, defaultSkin) == 64)
-				resModel = static_cast<HumanoidModel *>(newHumanoidModelSlim);
+				resModel = static_cast<HumanoidModel*>(newHumanoidModelSlim);
 			else
-				resModel = static_cast<HumanoidModel *>(humanoidModelSlim);
+				resModel = static_cast<HumanoidModel*>(humanoidModelSlim);
 		}
 		else
 		{
 			if (textures->getHeight(mob->customTextureUrl, defaultSkin) == 64)
-				resModel = static_cast<HumanoidModel *>(newHumanoidModel);
+				resModel = static_cast<HumanoidModel*>(newHumanoidModel);
 			else
-				resModel = static_cast<HumanoidModel *>(humanoidModel);
+				resModel = static_cast<HumanoidModel*>(humanoidModel);
 		}
 	}
 	else
-		resModel = static_cast<HumanoidModel *>(model);
+		resModel = static_cast<HumanoidModel*>(model);
 
 	/*if (mob != nullptr && newHumanoidModelSlim != nullptr && (mob->getCustomSkin() >= 10 && mob->getCustomSkin() <= 18)) resModel = newHumanoidModelSlim;
 	else if (mob != nullptr && newHumanoidModel != nullptr && (mob->getCustomSkin() >= 2 && mob->getCustomSkin() <= 9)) resModel = newHumanoidModel;
 	else resModel = humanoidModel;*/
 
-    shared_ptr<ItemInstance> item = mob->inventory->getSelected();
+	shared_ptr<ItemInstance> item = mob->inventory->getSelected();
 
 	armorParts1->holdingRightHand = armorParts2->holdingRightHand = resModel->holdingRightHand = item != nullptr ? 1 : 0;
 
@@ -272,11 +274,11 @@ void PlayerRenderer::render(shared_ptr<Entity> _mob, double x, double y, double
 		}
 	}
 	// 4J added, for 3rd person view of eating
-	if( item != nullptr && mob->getUseItemDuration() > 0 && item->getUseAnimation() == UseAnim_eat )
+	if (item != nullptr && mob->getUseItemDuration() > 0 && item->getUseAnimation() == UseAnim_eat)
 	{
 		// These factors are largely lifted from ItemInHandRenderer to try and keep the 3rd person eating animation as similar as possible
-        float t = (mob->getUseItemDuration() - a + 1);
-        float swing = 1 - (t / item->getUseDuration());
+		float t = (mob->getUseItemDuration() - a + 1);
+		float swing = 1 - (t / item->getUseDuration());
 
 		armorParts1->eating = armorParts2->eating = resModel->eating = true;
 		armorParts1->eating_t = armorParts2->eating_t = resModel->eating_t = t;
@@ -288,69 +290,69 @@ void PlayerRenderer::render(shared_ptr<Entity> _mob, double x, double y, double
 	}
 
 	armorParts1->sneaking = armorParts2->sneaking = resModel->sneaking = mob->isSneaking();
-    double yp = y - mob->heightOffset;
-    if (mob->isSneaking())
+	double yp = y - mob->heightOffset;
+	if (mob->isSneaking())
 	{
-        yp -= 2 / 16.0f;
-    }
+		yp -= 2 / 16.0f;
+	}
 
-    if (mob->getAnimOverrideBitmask() & (1 << HumanoidModel::eAnim_SmallModel))
-    {
-        if (mob->isRiding())
-        {
-            std::shared_ptr<Entity> ridingEntity = mob->riding;
-            if (ridingEntity != nullptr) // Safety check;
-            {
-                if (ridingEntity->instanceof(eTYPE_BOAT))
-                {
-                    yp += 0.25f; // reverts the change in Boat.cpp for smaller models.
-                }
-            }
-        }
-    }
+	if (mob->getAnimOverrideBitmask() & (1 << HumanoidModel::eAnim_SmallModel))
+	{
+		if (mob->isRiding())
+		{
+			std::shared_ptr<Entity> ridingEntity = mob->riding;
+			if (ridingEntity != nullptr) // Safety check;
+			{
+				if (ridingEntity->instanceof(eTYPE_BOAT))
+				{
+					yp += 0.25f; // reverts the change in Boat.cpp for smaller models.
+				}
+			}
+		}
+	}
 
 	// Check if an idle animation is needed
-	if(mob->getAnimOverrideBitmask()&(1<<HumanoidModel::eAnim_HasIdle))
+	if (mob->getAnimOverrideBitmask() & (1 << HumanoidModel::eAnim_HasIdle))
 	{
-		if(mob->isIdle())
+		if (mob->isIdle())
 		{
-			resModel->idle=true;
-			armorParts1->idle=true;
-			armorParts2->idle=true;
+			resModel->idle = true;
+			armorParts1->idle = true;
+			armorParts2->idle = true;
 		}
 		else
 		{
-			resModel->idle=false;
-			armorParts1->idle=false;
-			armorParts2->idle=false;
+			resModel->idle = false;
+			armorParts1->idle = false;
+			armorParts2->idle = false;
 		}
 	}
 	else
 	{
-		resModel->idle=false;
-		armorParts1->idle=false;
-		armorParts2->idle=false;
+		resModel->idle = false;
+		armorParts1->idle = false;
+		armorParts2->idle = false;
 	}
 
 	// 4J-PB - any additional parts to turn on for this player (skin dependent)
-	vector<ModelPart *> *pAdditionalModelParts=mob->GetAdditionalModelParts();
+	vector<ModelPart*>* pAdditionalModelParts = mob->GetAdditionalModelParts();
 	//turn them on
-	if(pAdditionalModelParts!=nullptr)
+	if (pAdditionalModelParts != nullptr)
 	{
-		for(ModelPart *pModelPart : *pAdditionalModelParts)
+		for (ModelPart* pModelPart : *pAdditionalModelParts)
 		{
-			pModelPart->visible=true;
+			pModelPart->visible = true;
 		}
 	}
 
-    LivingEntityRenderer::render(mob, x, yp, z, rot, a);
+	LivingEntityRenderer::render(mob, x, yp, z, rot, a);
 
 	// turn them off again
-	if(pAdditionalModelParts && pAdditionalModelParts->size()!=0)
+	if (pAdditionalModelParts && pAdditionalModelParts->size() != 0)
 	{
-		for(ModelPart *pModelPart : *pAdditionalModelParts)
+		for (ModelPart* pModelPart : *pAdditionalModelParts)
 		{
-			pModelPart->visible=false;
+			pModelPart->visible = false;
 		}
 	}
 	armorParts1->bowAndArrow = armorParts2->bowAndArrow = resModel->bowAndArrow = false;
@@ -361,55 +363,55 @@ void PlayerRenderer::render(shared_ptr<Entity> _mob, double x, double y, double
 void PlayerRenderer::additionalRendering(shared_ptr<LivingEntity> _mob, float a)
 {
 	float brightness = SharedConstants::TEXTURE_LIGHTING ? 1 : _mob->getBrightness(a);
-    glColor3f(brightness, brightness, brightness);
+	glColor3f(brightness, brightness, brightness);
 
-	LivingEntityRenderer::additionalRendering(_mob,a);
+	LivingEntityRenderer::additionalRendering(_mob, a);
 	LivingEntityRenderer::renderArrows(_mob, a);
 
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
 	shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
-	HumanoidModel *resModel = static_cast<HumanoidModel *>(model);
+	HumanoidModel* resModel = static_cast<HumanoidModel*>(model);
 
 	if (mob != nullptr)
 	{
-		Textures *textures = Minecraft::GetInstance()->textures;
+		Textures* textures = Minecraft::GetInstance()->textures;
 		int skinId = mob->getPlayerDefaultSkin() - 1;
 		int defaultSkin = mob->getPlayerDefaultSkin() + 35;
 
 		if (slim[skinId] == true)
 		{
 			if (textures->getHeight(mob->customTextureUrl, defaultSkin) == 64)
-				resModel = static_cast<HumanoidModel *>(newHumanoidModelSlim);
+				resModel = static_cast<HumanoidModel*>(newHumanoidModelSlim);
 			else
-				resModel = static_cast<HumanoidModel *>(humanoidModelSlim);
+				resModel = static_cast<HumanoidModel*>(humanoidModelSlim);
 		}
 		else
 		{
 			if (textures->getHeight(mob->customTextureUrl, defaultSkin) == 64)
-				resModel = static_cast<HumanoidModel *>(newHumanoidModel);
+				resModel = static_cast<HumanoidModel*>(newHumanoidModel);
 			else
-				resModel = static_cast<HumanoidModel *>(humanoidModel);
+				resModel = static_cast<HumanoidModel*>(humanoidModel);
 		}
 	}
 	else
-		resModel = static_cast<HumanoidModel *>(model);
+		resModel = static_cast<HumanoidModel*>(model);
 
 	/*if (mob != nullptr && newHumanoidModelSlim != nullptr && (mob->getCustomSkin() >= 10 && mob->getCustomSkin() <= 18)) resModel = newHumanoidModelSlim;
 	else if (mob != nullptr && newHumanoidModel != nullptr && (mob->getCustomSkin() >= 2 && mob->getCustomSkin() <= 9)) resModel = newHumanoidModel;
 	else resModel = humanoidModel;*/
 
-    shared_ptr<ItemInstance> headGear = mob->inventory->getArmor(3);
-    if (headGear != nullptr)
+	shared_ptr<ItemInstance> headGear = mob->inventory->getArmor(3);
+	if (headGear != nullptr)
 	{
 		// don't render the pumpkin for the skins
-		unsigned int uiAnimOverrideBitmask = mob->getSkinAnimOverrideBitmask( mob->getCustomSkin());
+		unsigned int uiAnimOverrideBitmask = mob->getSkinAnimOverrideBitmask(mob->getCustomSkin());
 
-		if((uiAnimOverrideBitmask&(1<<HumanoidModel::eAnim_DontRenderArmour))==0)
+		if ((uiAnimOverrideBitmask & (1 << HumanoidModel::eAnim_DontRenderArmour)) == 0)
 		{
 			glPushMatrix();
 			resModel->head->translateTo(1 / 16.0f);
 
-			if(headGear->getItem()->id < 256)
+			if (headGear->getItem()->id < 256)
 			{
 				if (TileRenderer::canRender(Tile::tiles[headGear->id]->getRenderShape()))
 				{
@@ -436,87 +438,87 @@ void PlayerRenderer::additionalRendering(shared_ptr<LivingEntity> _mob, float a)
 			//SkullTileRenderer::instance->renderSkull(-0.5f, 0, -0.5f, Facing::UP, 180, headGear->getAuxValue(), extra);
 			glPopMatrix();
 		}
-    }
+	}
 
 	// need to add a custom texture for deadmau5
-	if (mob != nullptr && app.isXuidDeadmau5( mob->getXuid() ) && bindTexture(mob->customTextureUrl, L"" ))
+	if (mob != nullptr && app.isXuidDeadmau5(mob->getXuid()) && bindTexture(mob->customTextureUrl, L""))
 	{
-        for (int i = 0; i < 2; i++)
+		for (int i = 0; i < 2; i++)
 		{
-            float yr = (mob->yRotO + (mob->yRot - mob->yRotO) * a) - (mob->yBodyRotO + (mob->yBodyRot - mob->yBodyRotO) * a);
-            float xr = mob->xRotO + (mob->xRot - mob->xRotO) * a;
-            glPushMatrix();
-            glRotatef(yr, 0, 1, 0);
-            glRotatef(xr, 1, 0, 0);
-            glTranslatef((6 / 16.0f) * (i * 2 - 1), 0, 0);
-            glTranslatef(0, -6 / 16.0f, 0);
-            glRotatef(-xr, 1, 0, 0);
-            glRotatef(-yr, 0, 1, 0);
+			float yr = (mob->yRotO + (mob->yRot - mob->yRotO) * a) - (mob->yBodyRotO + (mob->yBodyRot - mob->yBodyRotO) * a);
+			float xr = mob->xRotO + (mob->xRot - mob->xRotO) * a;
+			glPushMatrix();
+			glRotatef(yr, 0, 1, 0);
+			glRotatef(xr, 1, 0, 0);
+			glTranslatef((6 / 16.0f) * (i * 2 - 1), 0, 0);
+			glTranslatef(0, -6 / 16.0f, 0);
+			glRotatef(-xr, 1, 0, 0);
+			glRotatef(-yr, 0, 1, 0);
 
-            float s = 8 / 6.0f;
-            glScalef(s, s, s);
-			resModel->renderEars(1 / 16.0f,true);
-            glPopMatrix();
-        }
-    }
+			float s = 8 / 6.0f;
+			glScalef(s, s, s);
+			resModel->renderEars(1 / 16.0f, true);
+			glPopMatrix();
+		}
+	}
 
 	// 4J: removed
 	/*boolean loaded = mob->getCloakTexture()->isLoaded();
-    boolean b1 = !mob->isInvisible();
-    boolean b2 = !mob->isCapeHidden();*/
+	boolean b1 = !mob->isInvisible();
+	boolean b2 = !mob->isCapeHidden();*/
 	if (bindTexture(mob->customTextureUrl2, L"") && !mob->isInvisible())
 	{
-        glPushMatrix();
-        glTranslatef(0, 0, 2 / 16.0f);
+		glPushMatrix();
+		glTranslatef(0, 0, 2 / 16.0f);
 
-        double xd = (mob->xCloakO + (mob->xCloak - mob->xCloakO) * a) - (mob->xo + (mob->x - mob->xo) * a);
-        double yd = (mob->yCloakO + (mob->yCloak - mob->yCloakO) * a) - (mob->yo + (mob->y - mob->yo) * a);
-        double zd = (mob->zCloakO + (mob->zCloak - mob->zCloakO) * a) - (mob->zo + (mob->z - mob->zo) * a);
+		double xd = (mob->xCloakO + (mob->xCloak - mob->xCloakO) * a) - (mob->xo + (mob->x - mob->xo) * a);
+		double yd = (mob->yCloakO + (mob->yCloak - mob->yCloakO) * a) - (mob->yo + (mob->y - mob->yo) * a);
+		double zd = (mob->zCloakO + (mob->zCloak - mob->zCloakO) * a) - (mob->zo + (mob->z - mob->zo) * a);
 
-        float yr = mob->yBodyRotO + (mob->yBodyRot - mob->yBodyRotO) * a;
+		float yr = mob->yBodyRotO + (mob->yBodyRot - mob->yBodyRotO) * a;
 
-        double xa = Mth::sin(yr * PI / 180);
-        double za = -Mth::cos(yr * PI / 180);
+		double xa = Mth::sin(yr * PI / 180);
+		double za = -Mth::cos(yr * PI / 180);
 
-        float flap = static_cast<float>(yd) * 10;
-        if (flap < -6) flap = -6;
-        if (flap > 32) flap = 32;
-        float lean = static_cast<float>(xd * xa + zd * za) * 100;
-        float lean2 = static_cast<float>(xd * za - zd * xa) * 100;
-        if (lean < 0) lean = 0;
+		float flap = static_cast<float>(yd) * 10;
+		if (flap < -6) flap = -6;
+		if (flap > 32) flap = 32;
+		float lean = static_cast<float>(xd * xa + zd * za) * 100;
+		float lean2 = static_cast<float>(xd * za - zd * xa) * 100;
+		if (lean < 0) lean = 0;
 
-        float pow = mob->oBob + (mob->bob - mob->oBob) * a;
+		float pow = mob->oBob + (mob->bob - mob->oBob) * a;
 
-        flap += sin((mob->walkDistO + (mob->walkDist - mob->walkDistO) * a) * 6) * 32 * pow;
-        if (mob->isSneaking())
+		flap += sin((mob->walkDistO + (mob->walkDist - mob->walkDistO) * a) * 6) * 32 * pow;
+		if (mob->isSneaking())
 		{
-            flap += 25;
-        }
+			flap += 25;
+		}
 
 		// 4J Stu - Fix for sprint-flying causing the cape to rotate up by 180 degrees or more
 		float xRot = 6.0f + lean / 2 + flap;
-		if(xRot > 64.0f) xRot = 64.0f;
+		if (xRot > 64.0f) xRot = 64.0f;
 
-        glRotatef(xRot, 1, 0, 0);
-        glRotatef(lean2 / 2, 0, 0, 1);
-        glRotatef(-lean2 / 2, 0, 1, 0);
-        glRotatef(180, 0, 1, 0);
-		resModel->renderCloak(1 / 16.0f,true);
-        glPopMatrix();
-    }
+		glRotatef(xRot, 1, 0, 0);
+		glRotatef(lean2 / 2, 0, 0, 1);
+		glRotatef(-lean2 / 2, 0, 1, 0);
+		glRotatef(180, 0, 1, 0);
+		resModel->renderCloak(1 / 16.0f, true);
+		glPopMatrix();
+	}
 
-    shared_ptr<ItemInstance> item = mob->inventory->getSelected();
+	shared_ptr<ItemInstance> item = mob->inventory->getSelected();
 
-    if (item != nullptr)
+	if (item != nullptr)
 	{
-        glPushMatrix();
+		glPushMatrix();
 		resModel->arm0->translateTo(1 / 16.0f);
-        glTranslatef(-1 / 16.0f, 7 / 16.0f, 1 / 16.0f);
+		glTranslatef(-1 / 16.0f, 7 / 16.0f, 1 / 16.0f);
 
-        if (mob->fishing != nullptr)
+		if (mob->fishing != nullptr)
 		{
-            item = std::make_shared<ItemInstance>(Item::stick);
-        }
+			item = std::make_shared<ItemInstance>(Item::stick);
+		}
 
 		UseAnim anim = UseAnim_none;//null;
 		if (mob->getUseItemDuration() > 0)
@@ -524,14 +526,14 @@ void PlayerRenderer::additionalRendering(shared_ptr<LivingEntity> _mob, float a)
 			anim = item->getUseAnimation();
 		}
 
-        if (item->id < 256 && TileRenderer::canRender(Tile::tiles[item->id]->getRenderShape()))
+		if (item->id < 256 && TileRenderer::canRender(Tile::tiles[item->id]->getRenderShape()))
 		{
-            float s = 8 / 16.0f;
-            glTranslatef(-0 / 16.0f, 3 / 16.0f, -5 / 16.0f);
-            s *= 0.75f;
-            glRotatef(20, 1, 0, 0);
-            glRotatef(45, 0, 1, 0);
-            glScalef(-s, -s, s);
+			float s = 8 / 16.0f;
+			glTranslatef(-0 / 16.0f, 3 / 16.0f, -5 / 16.0f);
+			s *= 0.75f;
+			glRotatef(20, 1, 0, 0);
+			glRotatef(45, 0, 1, 0);
+			glScalef(-s, -s, s);
 		}
 		else if (item->id == Item::bow->id)
 		{
@@ -567,19 +569,19 @@ void PlayerRenderer::additionalRendering(shared_ptr<LivingEntity> _mob, float a)
 		}
 		else
 		{
-            float s = 6 / 16.0f;
-            glTranslatef(+4 / 16.0f, +3 / 16.0f, -3 / 16.0f);
-            glScalef(s, s, s);
-            glRotatef(60, 0, 0, 1);
-            glRotatef(-90, 1, 0, 0);
-            glRotatef(20, 0, 0, 1);
-        }
+			float s = 6 / 16.0f;
+			glTranslatef(+4 / 16.0f, +3 / 16.0f, -3 / 16.0f);
+			glScalef(s, s, s);
+			glRotatef(60, 0, 0, 1);
+			glRotatef(-90, 1, 0, 0);
+			glRotatef(20, 0, 0, 1);
+		}
 
 		if (item->getItem()->hasMultipleSpriteLayers())
 		{
 			for (int layer = 0; layer <= 1; layer++)
 			{
-				int col = item->getItem()->getColor(item,layer);
+				int col = item->getItem()->getColor(item, layer);
 				float red = ((col >> 16) & 0xff) / 255.0f;
 				float g = ((col >> 8) & 0xff) / 255.0f;
 				float b = ((col) & 0xff) / 255.0f;
@@ -591,42 +593,42 @@ void PlayerRenderer::additionalRendering(shared_ptr<LivingEntity> _mob, float a)
 		else
 		{
 			int col = item->getItem()->getColor(item, 0);
-            float red = ((col >> 16) & 0xff) / 255.0f;
-            float g = ((col >> 8) & 0xff) / 255.0f;
-            float b = ((col) & 0xff) / 255.0f;
+			float red = ((col >> 16) & 0xff) / 255.0f;
+			float g = ((col >> 8) & 0xff) / 255.0f;
+			float b = ((col) & 0xff) / 255.0f;
 
-            glColor4f(red, g, b, 1);
+			glColor4f(red, g, b, 1);
 			this->entityRenderDispatcher->itemInHandRenderer->renderItem(mob, item, 0);
 		}
 
-        glPopMatrix();
+		glPopMatrix();
 	}
 }
 
-void PlayerRenderer::renderNameTags(shared_ptr<LivingEntity> player, double x, double y, double z, const wstring &msg, float scale, double dist)
+void PlayerRenderer::renderNameTags(shared_ptr<LivingEntity> player, double x, double y, double z, const wstring& msg, float scale, double dist)
 {
 #if 0
-    if (dist < 10 * 10)
+	if (dist < 10 * 10)
 	{
-        Scoreboard *scoreboard = player->getScoreboard();
-        Objective *objective = scoreboard->getDisplayObjective(Scoreboard::DISPLAY_SLOT_BELOW_NAME);
+		Scoreboard* scoreboard = player->getScoreboard();
+		Objective* objective = scoreboard->getDisplayObjective(Scoreboard::DISPLAY_SLOT_BELOW_NAME);
 
-        if (objective != nullptr)
+		if (objective != nullptr)
 		{
-            Score *score = scoreboard->getPlayerScore(player->getAName(), objective);
+			Score* score = scoreboard->getPlayerScore(player->getAName(), objective);
 
-            if (player->isSleeping())
+			if (player->isSleeping())
 			{
-                renderNameTag(player, score->getScore() + " " + objective->getDisplayName(), x, y - 1.5f, z, 64);
-            }
+				renderNameTag(player, score->getScore() + " " + objective->getDisplayName(), x, y - 1.5f, z, 64);
+			}
 			else
 			{
-                renderNameTag(player, score->getScore() + " " + objective->getDisplayName(), x, y, z, 64);
-            }
+				renderNameTag(player, score->getScore() + " " + objective->getDisplayName(), x, y, z, 64);
+			}
 
-            y += getFont()->lineHeight * 1.15f * scale;
-        }
-    }
+			y += getFont()->lineHeight * 1.15f * scale;
+		}
+	}
 #endif
 
 	shared_ptr<Player> pPlayer = dynamic_pointer_cast<Player>(player);
@@ -644,53 +646,53 @@ void PlayerRenderer::renderNameTags(shared_ptr<LivingEntity> player, double x, d
 
 void PlayerRenderer::scale(shared_ptr<LivingEntity> player, float a)
 {
-    float s = 15 / 16.0f;
-    glScalef(s, s, s);
+	float s = 15 / 16.0f;
+	glScalef(s, s, s);
 }
 
 void PlayerRenderer::renderHand()
 {
 	shared_ptr<Player> player = dynamic_pointer_cast<Player>(Minecraft::GetInstance()->player);
-	HumanoidModel *resModel = static_cast<HumanoidModel *>(model);
+	HumanoidModel* resModel = static_cast<HumanoidModel*>(model);
 
 	if (player != nullptr)
 	{
-		Textures *textures = Minecraft::GetInstance()->textures;
+		Textures* textures = Minecraft::GetInstance()->textures;
 		int skinId = player->getPlayerDefaultSkin() - 1;
 		int defaultSkin = player->getPlayerDefaultSkin() + 35;
 
 		if (slim[skinId] == true)
 		{
 			if (textures->getHeight(player->customTextureUrl, defaultSkin) == 64)
-				resModel = static_cast<HumanoidModel *>(newHumanoidModelSlim);
+				resModel = static_cast<HumanoidModel*>(newHumanoidModelSlim);
 			else
-				resModel = static_cast<HumanoidModel *>(humanoidModelSlim);
+				resModel = static_cast<HumanoidModel*>(humanoidModelSlim);
 		}
 		else
 		{
 			if (textures->getHeight(player->customTextureUrl, defaultSkin) == 64)
-				resModel = static_cast<HumanoidModel *>(newHumanoidModel);
+				resModel = static_cast<HumanoidModel*>(newHumanoidModel);
 			else
-				resModel = static_cast<HumanoidModel *>(humanoidModel);
+				resModel = static_cast<HumanoidModel*>(humanoidModel);
 		}
 	}
 	else
-		resModel = static_cast<HumanoidModel *>(model);
+		resModel = static_cast<HumanoidModel*>(model);
 
 	/*if (player != nullptr && newHumanoidModelSlim != nullptr && (player->getCustomSkin() >= 10 && player->getCustomSkin() <= 18)) resModel = newHumanoidModelSlim;
 	else if (player != nullptr && newHumanoidModel != nullptr && (player->getCustomSkin() >= 2 && player->getCustomSkin() <= 9)) resModel = newHumanoidModel;
 	else resModel = humanoidModel;*/
 
 	float brightness = 1;
-    glColor3f(brightness, brightness, brightness);
+	glColor3f(brightness, brightness, brightness);
 
 	resModel->m_uiAnimOverrideBitmask = player->getAnimOverrideBitmask();
 	armorParts1->eating = armorParts2->eating = resModel->eating = resModel->idle = false;
 	resModel->attackTime = 0;
 	resModel->setupAnim(0, 0, 0, 0, 0, 1 / 16.0f, Minecraft::GetInstance()->player);
 	// 4J-PB - does this skin have its arm0 disabled? (Dalek, etc)
-	if((resModel->m_uiAnimOverrideBitmask&(1<<HumanoidModel::eAnim_DisableRenderArm0))==0)
-		resModel->arm0->render(1 / 16.0f,true);
+	if ((resModel->m_uiAnimOverrideBitmask & (1 << HumanoidModel::eAnim_DisableRenderArm0)) == 0)
+		resModel->arm0->render(1 / 16.0f, true);
 
 	//Render custom skin boxes on viewmodel - Botch
 	vector<ModelPart*>* additionalModelParts = Minecraft::GetInstance()->player->GetAdditionalModelParts();
@@ -718,19 +720,19 @@ void PlayerRenderer::setupPosition(shared_ptr<LivingEntity> _mob, double x, doub
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
 	shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
 
-    if (mob->isAlive() && mob->isSleeping())
+	if (mob->isAlive() && mob->isSleeping())
 	{
-        LivingEntityRenderer::setupPosition(mob, x + mob->bedOffsetX, y + mob->bedOffsetY, z + mob->bedOffsetZ);
+		LivingEntityRenderer::setupPosition(mob, x + mob->bedOffsetX, y + mob->bedOffsetY, z + mob->bedOffsetZ);
 
-    }
+	}
 	else
 	{
-		if(mob->isRiding() && (mob->getAnimOverrideBitmask()&(1<<HumanoidModel::eAnim_SmallModel))!=0)
+		if (mob->isRiding() && (mob->getAnimOverrideBitmask() & (1 << HumanoidModel::eAnim_SmallModel)) != 0)
 		{
 			y += 0.5f;
 		}
-        LivingEntityRenderer::setupPosition(mob, x, y, z);
-    }
+		LivingEntityRenderer::setupPosition(mob, x, y, z);
+	}
 }
 
 void PlayerRenderer::setupRotations(shared_ptr<LivingEntity> _mob, float bob, float bodyRot, float a)
@@ -738,27 +740,27 @@ void PlayerRenderer::setupRotations(shared_ptr<LivingEntity> _mob, float bob, fl
 	// 4J - dynamic cast required because we aren't using templates/generics in our version
 	shared_ptr<Player> mob = dynamic_pointer_cast<Player>(_mob);
 
-    if (mob->isAlive() && mob->isSleeping())
+	if (mob->isAlive() && mob->isSleeping())
 	{
-        glRotatef(mob->getSleepRotation(), 0, 1, 0);
-        glRotatef(getFlipDegrees(mob), 0, 0, 1);
-        glRotatef(270, 0, 1, 0);
-    }
+		glRotatef(mob->getSleepRotation(), 0, 1, 0);
+		glRotatef(getFlipDegrees(mob), 0, 0, 1);
+		glRotatef(270, 0, 1, 0);
+	}
 	else
 	{
-        LivingEntityRenderer::setupRotations(mob, bob, bodyRot, a);
-    }
+		LivingEntityRenderer::setupRotations(mob, bob, bodyRot, a);
+	}
 }
 
 // 4J Added override to stop rendering shadow if player is invisible
 void PlayerRenderer::renderShadow(shared_ptr<Entity> e, double x, double y, double z, float pow, float a)
 {
-	if(app.GetGameHostOption(eGameHostOption_HostCanBeInvisible) > 0)
+	if (app.GetGameHostOption(eGameHostOption_HostCanBeInvisible) > 0)
 	{
 		shared_ptr<Player> player = dynamic_pointer_cast<Player>(e);
-		if(player != nullptr && player->hasInvisiblePrivilege()) return;
+		if (player != nullptr && player->hasInvisiblePrivilege()) return;
 	}
-	EntityRenderer::renderShadow(e,x,y,z,pow,a);
+	EntityRenderer::renderShadow(e, x, y, z, pow, a);
 }
 
 // 4J Added override
@@ -768,7 +770,7 @@ void PlayerRenderer::bindTexture(shared_ptr<Entity> entity)
 	bindTexture(player->customTextureUrl, player->getTexture());
 }
 
-ResourceLocation *PlayerRenderer::getTextureLocation(shared_ptr<Entity> entity)
+ResourceLocation* PlayerRenderer::getTextureLocation(shared_ptr<Entity> entity)
 {
 	shared_ptr<Player> player = dynamic_pointer_cast<Player>(entity);
 	return new ResourceLocation(static_cast<_TEXTURE_NAME>(player->getTexture()));
diff --git a/Minecraft.Client/PlayerRenderer.h b/Minecraft.Client/PlayerRenderer.h
index ce61abb3..8accdc7f 100644
--- a/Minecraft.Client/PlayerRenderer.h
+++ b/Minecraft.Client/PlayerRenderer.h
@@ -21,6 +21,7 @@ private:
     HumanoidModel *armorParts1;
     HumanoidModel *armorParts2;
     HumanoidModel *armorParts3;
+    HumanoidModel *armorParts4;
 	bool defaultSlimHands;
 
 	static ResourceLocation SKELETON_LOCATION;
diff --git a/Minecraft.Client/SkullTileRenderer.cpp b/Minecraft.Client/SkullTileRenderer.cpp
index 170779db..3822e3af 100644
--- a/Minecraft.Client/SkullTileRenderer.cpp
+++ b/Minecraft.Client/SkullTileRenderer.cpp
@@ -48,31 +48,13 @@ void SkullTileRenderer::renderSkull(float x, float y, float z, int face, float r
 		break;
 	case SkullTileEntity::TYPE_ZOMBIE:
 		bindTexture(&ZOMBIE_LOCATION);
-		//model = zombieModel;
+		model = skeletonModel;
 		break;
 	case SkullTileEntity::TYPE_CHAR:
 	{
 		Textures *textures = Minecraft::GetInstance()->textures;
-
-		if (getHeight(&PlayerRenderer::DEFAULT_LOCATION) == 64)
-		{
-			model = new SkeletonHeadModel(0, 0, 64, 64);
-		}
-		//if (!extra.empty())
-		//{
-		//	wstring url = "http://skins.minecraft.net/MinecraftSkins/" + StringUtil.stripColor(extra) + ".png";
-
-		//	if (!instance->tileEntityRenderDispatcher->textures->hasHttpTexture(url))
-		//	{
-		//		instance->tileEntityRenderDispatcher->textures->addHttpTexture(url, new MobSkinTextureProcessor());
-		//	}
-
-		//	bindTexture(url, "/mob/char.png");
-		//}
-		//else
-		{
-			bindTexture(&PlayerRenderer::DEFAULT_LOCATION);
-		}
+		model = zombieModel;
+		bindTexture(&PlayerRenderer::DEFAULT_LOCATION);
 		break;
 	}
 	case SkullTileEntity::TYPE_CREEPER:
diff --git a/Minecraft.Server/FourKitNatives.cpp b/Minecraft.Server/FourKitNatives.cpp
index f634e825..758aea7e 100644
--- a/Minecraft.Server/FourKitNatives.cpp
+++ b/Minecraft.Server/FourKitNatives.cpp
@@ -33,6 +33,7 @@
 #include "../Minecraft.World/SetHealthPacket.h"
 #include "../Minecraft.World/LevelSoundPacket.h"
 #include "../Minecraft.World/LevelParticlesPacket.h"
+#include "../Minecraft.Client/ParticleType.h"
 #include "../Minecraft.World/SetEntityLinkPacket.h"
 #include "../Minecraft.World/SimpleContainer.h"
 #include "../Minecraft.World/Slot.h"
@@ -633,9 +634,6 @@ int __cdecl NativeSendRaw(int entityId, unsigned char *bufferData, int bufferSiz
 
 void WriteInventoryItemData(std::shared_ptr<ItemInstance> item, int index, int* outBuffer) {
     if (item) {
-        //ItemFlags Key:
-        // 0x1 = hasMetadata (has data that needs to be gotten from "ReadMetaFromNative")
-
         uint8_t itemFlags = 0;
         if (item->getTag() == nullptr) goto doneWithMetadataFlag;
         CompoundTag* itemTag = item->getTag();
@@ -644,7 +642,7 @@ void WriteInventoryItemData(std::shared_ptr<ItemInstance> item, int index, int*
             itemFlags |= 0x1;
             goto doneWithMetadataFlag;
         }
-        else { //we just want to check one tag for metadata and return for this flag, not all of them
+        else {
             CompoundTag* displayTag = itemTag->getCompound(L"display");
             if (displayTag->contains(L"Name") || displayTag->contains(L"Lore")) {
                 itemFlags |= 0x1;
@@ -652,9 +650,7 @@ void WriteInventoryItemData(std::shared_ptr<ItemInstance> item, int index, int*
             }
         }
 
-
     doneWithMetadataFlag:
-
         outBuffer[(index * 3) + 0] = item->id;
         outBuffer[(index * 3) + 1] = item->getAuxValue();
         outBuffer[(index * 3) + 2] = (((int)itemFlags << 24) | ((int)item->count << 8));
@@ -663,9 +659,6 @@ void WriteInventoryItemData(std::shared_ptr<ItemInstance> item, int index, int*
 
 void __cdecl NativeGetPlayerInventory(int entityId, int *outData)
 {
-    // 9 slots per row, 3 slots in the inventory and the hotbar, 4 armor slots, 1 hand slot
-    // (((slotsPerRow * Rows) + ArmorSlots) * AmountOfIntsPerSlot) + hand slot
-    // (((9 * 4) + 4) * 3) + 1 = 121
     memset(outData, 0, 121 * sizeof(int));
 
     auto player = FindPlayer(entityId);
@@ -806,8 +799,7 @@ void __cdecl NativeOpenVirtualContainer(int entityId, int nativeType, const char
 
     player->openContainer(container);
 }
-//didnt update this for enchants
-// [nameLen:int32][nameUTF8:bytes][loreCount:int32][lore0Len:int32][lore0UTF8:bytes]
+
 int __cdecl NativeGetItemMeta(int entityId, int slot, char *outBuf, int bufSize)
 {
     auto player = FindPlayer(entityId);
@@ -829,7 +821,6 @@ int __cdecl NativeGetItemMeta(int entityId, int slot, char *outBuf, int bufSize)
     CompoundTag *display = tag->getCompound(L"display");
     bool hasName = display->contains(L"Name");
     bool hasLore = display->contains(L"Lore");
-
     bool hasEnchantments = item->isEnchanted();
 
     if (!hasName && !hasLore)
@@ -888,18 +879,14 @@ int __cdecl NativeGetItemMeta(int entityId, int slot, char *outBuf, int bufSize)
         ListTag<CompoundTag>* list = item->getEnchantmentTags();
         if (list != nullptr) {
             int listSize = list->size();
-
             if ((offset + 4 + (listSize * (4 + 4))) > bufSize) return 0;
-
             memcpy(outBuf + offset, &listSize, 4);
             offset += 4;
             for (int i = 0; i < listSize; i++) {
                 int type = list->get(i)->getShort((wchar_t*)ItemInstance::TAG_ENCH_ID);
                 int level = list->get(i)->getShort((wchar_t*)ItemInstance::TAG_ENCH_LEVEL);
-
                 memcpy(outBuf + offset, &type, 4);
                 offset += 4;
-
                 memcpy(outBuf + offset, &level, 4);
                 offset += 4;
             }
@@ -946,11 +933,8 @@ void __cdecl NativeSetItemMeta(int entityId, int slot, const char *inBuf, int bu
                         item->setTag(nullptr);
                 }
             }
-
             if (tag && tag->contains(L"ench"))
-            {
                 tag->remove(L"ench");
-            }
         }
         return;
     }
@@ -1030,15 +1014,12 @@ void __cdecl NativeSetItemMeta(int entityId, int slot, const char *inBuf, int bu
 
         for (int i = 0; i < enchantCount; i++) {
             if (offset + (4 + 4) > bufSize) break;
-
             int type = 0;
             memcpy(&type, inBuf + offset, 4);
             offset += 4;
-
             int level = 0;
             memcpy(&level, inBuf + offset, 4);
             offset += 4;
-
             CompoundTag* ench = new CompoundTag();
             ench->putShort((wchar_t*)ItemInstance::TAG_ENCH_ID, static_cast<short>(type));
             ench->putShort((wchar_t*)ItemInstance::TAG_ENCH_LEVEL, static_cast<byte>(level));
@@ -1051,9 +1032,7 @@ void __cdecl NativeSetItemMeta(int entityId, int slot, const char *inBuf, int bu
         {
             CompoundTag* tag = item->getTag();
             if (tag && tag->contains(L"ench"))
-            {
                 tag->remove(L"ench");
-            }
         }
     }
 }
@@ -1190,13 +1169,15 @@ void __cdecl NativeSetExhaustion(int entityId, float exhaustion)
     fd->setExhaustion(exhaustion);
 }
 
+
 void __cdecl NativeSpawnParticle(int entityId, int particleId, float x, float y, float z, float offsetX, float offsetY, float offsetZ, float speed, int count)
 {
     auto player = FindPlayer(entityId);
     if (!player || !player->connection) return;
-    wchar_t buf[32];
-    swprintf_s(buf, L"%d", particleId);
-    player->connection->send(std::make_shared<LevelParticlesPacket>(std::wstring(buf), x, y, z, offsetX, offsetY, offsetZ, speed, count));
+    const ParticleType* type = ParticleType::byId(particleId);
+    if (!type) type = ParticleType::getDefault();
+    arrayWithLength<int> noParams = { nullptr, 0 };
+    player->connection->send(std::make_shared<LevelParticlesPacket>(type, false, x, y, z, offsetX, offsetY, offsetZ, speed, count, noParams));
 }
 
 int __cdecl NativeSetPassenger(int entityId, int passengerEntityId)
@@ -1268,4 +1249,4 @@ void __cdecl NativeGetEntityInfo(int entityId, double *outData)
     outData[4] = (double)entity->dimension;
 }
 
-} // namespace FourKitBridge
+} // namespace FourKitBridge
\ No newline at end of file
diff --git a/Minecraft.Server/cmake/sources/Common.cmake b/Minecraft.Server/cmake/sources/Common.cmake
index 9215df80..1db8331e 100644
--- a/Minecraft.Server/cmake/sources/Common.cmake
+++ b/Minecraft.Server/cmake/sources/Common.cmake
@@ -547,6 +547,17 @@ set(_MINECRAFT_SERVER_COMMON_ROOT
   "${_MS_SRC}/../include/lce_filesystem/lce_filesystem.cpp"
   "${_MS_SRC}/Console/ServerCliInput.cpp"
   "${_MS_SRC}/Console/ServerCliInput.h"
+  "${_MS_SRC}/../Minecraft.Client/AbstractArmorLayer.h"
+  "${_MS_SRC}/../Minecraft.Client/AbstractArmorLayer.cpp"
+  "${_MS_SRC}/../Minecraft.Client/HumanoidArmorLayer.h"
+  "${_MS_SRC}/../Minecraft.Client/HumanoidArmorLayer.cpp"
+  "${_MS_SRC}/../Minecraft.Client/ArmorStandArmorModel.h"
+  "${_MS_SRC}/../Minecraft.Client/ArmorStandArmorModel.cpp"
+  "${_MS_SRC}/../Minecraft.Client/ItemInHandLayer.h"
+  "${_MS_SRC}/../Minecraft.Client/ItemInHandLayer.cpp"
+  "${_MS_SRC}/../Minecraft.Client/CustomHeadLayer.h"
+  "${_MS_SRC}/../Minecraft.Client/CustomHeadLayer.cpp"
+  "${_MS_SRC}/../Minecraft.Client/RenderLayer.h"
 )
 source_group("" FILES ${_MINECRAFT_SERVER_COMMON_ROOT})
 
diff --git a/Minecraft.World/ArmorStand.cpp b/Minecraft.World/ArmorStand.cpp
index 999917d4..c130a913 100644
--- a/Minecraft.World/ArmorStand.cpp
+++ b/Minecraft.World/ArmorStand.cpp
@@ -35,11 +35,13 @@ void ArmorStand::init()
     registerAttributes();
     defineSynchedData();
 
-    lastHit = 0;
+    lastHit       = -100LL;
+    standDamage   = 0.0f;
+    hurtDir       = 1;
     disabledSlots = 0;
     invisible     = false;
     isMarkerFlag  = false;
-
+    heightOffset = 0.0f;
     for (int i = 0; i < equipmentCount; i++)
         equipment[i] = nullptr;
 
@@ -56,7 +58,6 @@ void ArmorStand::init()
     setSize(0.5f, 1.975f);
 }
 
-
 void ArmorStand::registerAttributes()
 {
     LivingEntity::registerAttributes();
@@ -68,8 +69,7 @@ void ArmorStand::registerAttributes()
 void ArmorStand::defineSynchedData()
 {
     LivingEntity::defineSynchedData();
-    // ArmorStand doesn't inherit from Mob, so we must register
-    // the custom-name fields that Mob::defineSynchedData() normally provides.
+    
     entityData->define(3, static_cast<byte>(0));   // DATA_CUSTOM_NAME_VISIBLE
     entityData->define(2, wstring(L""));            // DATA_CUSTOM_NAME
     entityData->define(DATA_CLIENT_FLAGS,   static_cast<byte>(0));
@@ -193,13 +193,27 @@ void ArmorStand::tick()
 {
     float lockedRot = this->yRot;
     LivingEntity::tick();
-    this->yRot = lockedRot;
-    this->yRotO = lockedRot;       
-    this->yBodyRot = lockedRot;
+    if (onGround)
+    {
+    BlockPos pos((int)floorf(x), (int)floorf(y) - 1, (int)floorf(z));
+    int blockId = level->getTile(pos.getX(), pos.getY(), pos.getZ());
+    if (blockId == Tile::topSnow->id)
+    {
+        int meta = level->getData(pos.getX(), pos.getY(), pos.getZ());
+        float snowHeight = ((meta & 0x7) + 1) * 0.125f;
+        moveTo(x, floorf(y) + snowHeight, z, yRot, xRot);
+    }
+    }
+    this->yRot      = lockedRot;
+    this->yRotO     = lockedRot;
+    this->yBodyRot  = lockedRot;
     this->yBodyRotO = lockedRot;
-    this->yHeadRot = lockedRot;
+    this->yHeadRot  = lockedRot;
     this->yHeadRotO = lockedRot;
 
+    if ((long long)tickCount - lastHit > 20)
+        standDamage = 0.0f;
+
     auto syncPose = [&](int slot, Rotations& local)
     {
         Rotations net = entityData->getRotations(slot);
@@ -254,6 +268,7 @@ void ArmorStand::causeDamage(float damage)
     h -= damage;
     if (h <= 0.5f)
     {
+        spawnAtLocation(Item::armor_stand_Id, 1);
         brokenByAnything();
         remove();
     }
@@ -266,59 +281,63 @@ void ArmorStand::causeDamage(float damage)
 bool ArmorStand::hurt(DamageSource* source, float damage)
 {
     if (isInvulnerable() || level->isClientSide || removed || isMarker()) return false;
-    if (source != nullptr && source->getMsgId() == eEntityDamageType_Suffocate) return false;
 
-    if (source->isExplosion())
-    {
-        brokenByAnything();
-        remove();
-        return true;
-    }
-
-    bool isFireDamage = source->isFire();
+    if (source->getMsgId() == eEntityDamageType_Suffocate) return false;
 
     if (dynamic_cast<EntityDamageSource*>(source) != nullptr)
     {
-        shared_ptr<Entity> attacker = source->getEntity();
-        if (attacker != nullptr && attacker->instanceof(eTYPE_PLAYER))
-        {
-            if (dynamic_pointer_cast<Player>(attacker)->abilities.instabuild)
-            {
-                level->broadcastEntityEvent(shared_from_this(), (byte)31);
-                remove();
-                return true;
-            }
-        }
+        shared_ptr<Entity> attacker = source->getDirectEntity();
+        if (attacker && attacker->instanceof(eTYPE_PLAYER) &&
+            !dynamic_pointer_cast<Player>(attacker)->isAllowedToHurtEntity(shared_from_this()))
+            return false;
     }
 
-    if (isFireDamage)
+    if (source->isExplosion())
     {
-        float currentHealth = this->getHealth() - 0.15f;
-        this->setHealth(currentHealth);
-        if (currentHealth <= 0.5f)
-        {
-            brokenByAnything();
-            remove();
-            return true;
-        }
-        return false;
-    }
-
-    long long now = (long long)tickCount;
-    if (now - lastHit > 5)
-    {
-        level->broadcastEntityEvent(shared_from_this(), (byte)32);
-        lastHit = now;
-        return true;
-    }
-    else
-    {
-        level->broadcastEntityEvent(shared_from_this(), (byte)31);
         spawnAtLocation(Item::armor_stand_Id, 1);
         brokenByAnything();
         remove();
         return true;
     }
+
+    if (dynamic_cast<EntityDamageSource*>(source) != nullptr)
+    {
+        shared_ptr<Entity> attacker = source->getEntity();
+        if (attacker && attacker->instanceof(eTYPE_PLAYER) &&
+            dynamic_pointer_cast<Player>(attacker)->abilities.instabuild)
+        {
+            level->broadcastEntityEvent(shared_from_this(), (byte)31);
+            remove();
+            return true;
+        }
+    }
+
+    if (source->isFire())
+    {
+        if (isInWater()) return false;
+        float h = getHealth() - 0.15f;
+        setHealth(h);
+        if (h <= 0.5f)
+        {
+            brokenByAnything();
+            remove();
+        }
+        return false;
+    }
+
+    hurtDir = -hurtDir;
+    standDamage += damage * 10.0f;
+    lastHit = (long long)tickCount;
+    level->broadcastEntityEvent(shared_from_this(), (byte)32);
+
+    if (standDamage >= 40.0f)
+    {
+        spawnAtLocation(Item::armor_stand_Id, 1);
+        brokenByAnything();
+        remove();
+    }
+
+    return true;
 }
 
 
diff --git a/Minecraft.World/ArmorStand.h b/Minecraft.World/ArmorStand.h
index efbf79ca..629d08aa 100644
--- a/Minecraft.World/ArmorStand.h
+++ b/Minecraft.World/ArmorStand.h
@@ -55,9 +55,11 @@ private:
     bool invisible;
     bool isMarkerFlag;
     bool noPhysics;
+    float standDamage;
 
 public:
     long long lastHit;
+    int hurtDir;
 
     explicit ArmorStand(Level* level);
     virtual ~ArmorStand();
diff --git a/Minecraft.World/cmake/sources/Common.cmake b/Minecraft.World/cmake/sources/Common.cmake
index 909aa605..8757c517 100644
--- a/Minecraft.World/cmake/sources/Common.cmake
+++ b/Minecraft.World/cmake/sources/Common.cmake
@@ -433,6 +433,8 @@ set(_MINECRAFT_WORLD_COMMON_NET_MINECRAFT_NETWORK_PACKET
   "${CMAKE_CURRENT_SOURCE_DIR}/XZPacket.cpp"
   "${CMAKE_CURRENT_SOURCE_DIR}/XZPacket.h"
   "${CMAKE_CURRENT_SOURCE_DIR}/net.minecraft.network.packet.h"
+   "${CMAKE_CURRENT_SOURCE_DIR}/../Minecraft.Client/ParticleType.h"
+  "${CMAKE_CURRENT_SOURCE_DIR}/../Minecraft.Client/ParticleType.cpp"
 )
 source_group("net/minecraft/network/packet" FILES ${_MINECRAFT_WORLD_COMMON_NET_MINECRAFT_NETWORK_PACKET})