//
// Copyright (c) 2008-2016 the Urho3D project.
// Copyright (c) 2014-2016, THUNDERBEAST GAMES LLC All rights reserved
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//

#include <Atomic/Core/CoreEvents.h>
#include <Atomic/Engine/Engine.h>
#include <Atomic/Graphics/AnimatedModel.h>
#include <Atomic/Graphics/Camera.h>
#include <Atomic/Graphics/DebugRenderer.h>
#include <Atomic/Graphics/Graphics.h>
#include <Atomic/Graphics/Light.h>
#include <Atomic/Graphics/Material.h>
#include <Atomic/Graphics/Octree.h>
#include <Atomic/Graphics/Renderer.h>
#include <Atomic/Graphics/Zone.h>
#include <Atomic/Input/Input.h>
#include <Atomic/IO/File.h>
#include <Atomic/IO/FileSystem.h>
#include <Atomic/Physics/CollisionShape.h>
#include <Atomic/Physics/PhysicsWorld.h>
#include <Atomic/Physics/RigidBody.h>
#include <Atomic/Resource/ResourceCache.h>
#include <Atomic/Scene/Scene.h>
#include <Atomic/UI/UI.h>
#include <Atomic/Atomic2D/StaticSprite2D.h>
#include <Atomic/Atomic2D/AnimationSet2D.h>
#include <Atomic/Atomic2D/AnimatedSprite2D.h>
#include <Atomic/Atomic2D/Sprite2D.h>
#include <Atomic/Graphics/RenderPath.h>
#include <Atomic/Resource/XMLFile.h>

#include "CreateRagdoll.h"
#include "Ragdolls.h"

#include <Atomic/DebugNew.h>

Ragdolls::Ragdolls(Context* context) :
    Sample(context),
    drawDebug_(false)
{
    // Register an object factory for our custom CreateRagdoll component so that we can create them to scene nodes
    context->RegisterFactory<CreateRagdoll>();
    
    massCount = 2;
    speedCount = 2;
    sizeCount = 2;

    bulletMass.Push(1.0f);
    bulletMass.Push(10.0f);
    bulletMass.Push(50.0f);
    bulletMass.Push(100.0f);
    bulletMass.Push(300.0f);
    bulletMass.Push(666.0f);
    bulletMass.Push(1000.0f);
    bulletSpeed.Push(10.0f);
    bulletSpeed.Push(22.0f);
    bulletSpeed.Push(41.0f);
    bulletSpeed.Push(72.0f);
    bulletSpeed.Push(116.0f);
    bulletSpeed.Push(200.0f);
    bulletSpeed.Push(450.0f);
    bulletSize.Push(0.25f);
    bulletSize.Push(0.5f);
    bulletSize.Push(1.25f);
    bulletSize.Push(3.25f);
    bulletSize.Push(5.25f);
    bulletSize.Push(7.25f);
    bulletSize.Push(11.25f);
    bulletSize.Push(16.25f);

    bulletArc = 0.25f;

}

void Ragdolls::Start()
{
    // Execute base class startup
    Sample::Start();

    // Create the scene content
    CreateScene();

    // add an overlay HUD that tells you settings
    CreateHUD();

    // Create the UI content
    CreateInstructions();

    // Setup the viewport for displaying the scene
    SetupViewport();

    // Hook up to the frame update and render post-update events
    SubscribeToEvents();

    // Set the mouse mode to use in the sample
    Sample::InitMouseMode(MM_ABSOLUTE);
    
    RestartJacks ();

    UpdateSpeedHud (speedCount);
    UpdateMassHud (massCount);
    UpdateSizeHud (sizeCount);

    GetSubsystem<Input>()->SetMouseVisible (false);

}

void Ragdolls::CreateScene()
{
    ResourceCache* cache = GetSubsystem<ResourceCache>();

    scene_ = new Scene(context_);

    // Create octree, use default volume (-1000, -1000, -1000) to (1000, 1000, 1000)
    // Create a physics simulation world with default parameters, which will update at 60fps. Like the Octree must
    // exist before creating drawable components, the PhysicsWorld must exist before creating physics components.
    // Finally, create a DebugRenderer component so that we can draw physics debug geometry
    scene_->CreateComponent<Octree>();
    scene_->CreateComponent<PhysicsWorld>();
    scene_->CreateComponent<DebugRenderer>();

    // Create a Zone component for ambient lighting & fog control
    Node* zoneNode = scene_->CreateChild("Zone");
    Zone* zone = zoneNode->CreateComponent<Zone>();
    zone->SetBoundingBox(BoundingBox(-1000.0f, 1000.0f));
    zone->SetAmbientColor(Color(0.15f, 0.15f, 0.15f));
    zone->SetFogColor(Color(0.5f, 0.5f, 0.7f));
    zone->SetFogStart(100.0f);
    zone->SetFogEnd(300.0f);

    // Create a directional light to the world. Enable cascaded shadows on it
    Node* lightNode = scene_->CreateChild("DirectionalLight");
    lightNode->SetDirection(Vector3(0.6f, -1.0f, 0.8f));
    Light* light = lightNode->CreateComponent<Light>();
    light->SetLightType(LIGHT_DIRECTIONAL);
    light->SetCastShadows(true);
    light->SetShadowBias(BiasParameters(0.00025f, 0.5f));
    // Set cascade splits at 10, 50 and 200 world units, fade shadows out at 80% of maximum shadow distance
    light->SetShadowCascade(CascadeParameters(10.0f, 50.0f, 200.0f, 0.0f, 0.8f));

    // Create a floor object, 500 x 500 world units. Adjust position so that the ground is at zero Y
    Node* floorNode = scene_->CreateChild("Floor");
    floorNode->SetPosition(Vector3(0.0f, -0.5f, 0.0f));
    floorNode->SetScale(Vector3(500.0f, 1.0f, 500.0f));
    StaticModel* floorObject = floorNode->CreateComponent<StaticModel>();
    floorObject->SetModel(cache->GetResource<Model>("Models/Box.mdl"));
    floorObject->SetMaterial(cache->GetResource<Material>("Materials/StoneTiled.xml"));

    // Make the floor physical by adding RigidBody and CollisionShape components
    RigidBody* body = floorNode->CreateComponent<RigidBody>();
    // We will be spawning spherical objects in this sample. The ground also needs non-zero rolling friction so that
    // the spheres will eventually come to rest
    body->SetRollingFriction(0.15f);
    CollisionShape* shape = floorNode->CreateComponent<CollisionShape>();
    // Set a box shape of size 1 x 1 x 1 for collision. The shape will be scaled with the scene node scale, so the
    // rendering and physics representation sizes should match (the box model is also 1 x 1 x 1.)
    shape->SetBox(Vector3::ONE);

    // Create the camera. Limit far clip distance to match the fog. Note: now we actually create the camera node outside
    // the scene, because we want it to be unaffected by scene load / save
    cameraNode_ = new Node(context_);
    Camera* camera = cameraNode_->CreateComponent<Camera>();
    camera->SetFarClip(300.0f);

    // Set an initial position for the camera scene node above the floor
    cameraNode_->SetPosition(Vector3(0.0f, 3.0f, -20.0f));
}

void Ragdolls::CreateInstructions()
{
    SimpleCreateInstructions (
        "Use WASD keys and mouse/touch to move\n"
        "LMB to spawn physics objects\n"
        "F5 to save scene, F7 to load\n"
        "Space to toggle physics debug geometry"
    );
}

void Ragdolls::SetupViewport()
{
    Renderer* renderer = GetSubsystem<Renderer>();
    ResourceCache* cache = GetSubsystem<ResourceCache>();
   
    renderer->SetNumViewports(2);  // use 2 viewports, 1 for 3d and 1 for the 2d hud
    Viewport* viewport2_ = new Viewport(context_, hudScene, hudCamera );  // hud orthographic viewport, scene and camera
    RenderPath *overlayRenderPath = new RenderPath(); 
    overlayRenderPath->Load(cache->GetResource<XMLFile>("PostProcess/FrontPath.xml"));  //special renderpath that does not clear
    viewport2_->SetRenderPath(overlayRenderPath);  // apply to hud viewport, so the background is transparent
    renderer->SetViewport(0, new Viewport(context_, scene_, cameraNode_->GetComponent<Camera>())); // perspective viewport, scene and camera
    renderer->SetViewport(1, viewport2_);  // and add in the HUD viewport
}

void Ragdolls::MoveCamera(float timeStep)
{

    Input* input = GetSubsystem<Input>();

    // Movement speed as world units per second
    const float MOVE_SPEED = 20.0f;
    // Mouse sensitivity as degrees per pixel
    const float MOUSE_SENSITIVITY = 0.1f;

    // Use this frame's mouse motion to adjust camera node yaw and pitch. Clamp the pitch between -90 and 90 degrees
    IntVector2 mouseMove = input->GetMouseMove();
    yaw_ += MOUSE_SENSITIVITY * mouseMove.x_;
    pitch_ += MOUSE_SENSITIVITY * mouseMove.y_;
    pitch_ = Clamp(pitch_, -90.0f, 90.0f);

    // Construct new orientation for the camera scene node from yaw and pitch. Roll is fixed to zero
    cameraNode_->SetRotation(Quaternion(pitch_, yaw_, 0.0f));

    // Read WASD keys and move the camera scene node to the corresponding direction if they are pressed
    if (input->GetKeyDown(KEY_W))
        cameraNode_->Translate(Vector3::FORWARD * MOVE_SPEED * timeStep);
    if (input->GetKeyDown(KEY_S))
        cameraNode_->Translate(Vector3::BACK * MOVE_SPEED * timeStep);
    if (input->GetKeyDown(KEY_A))
        cameraNode_->Translate(Vector3::LEFT * MOVE_SPEED * timeStep);
    if (input->GetKeyDown(KEY_D))
        cameraNode_->Translate(Vector3::RIGHT * MOVE_SPEED * timeStep);

    // "Shoot" a physics object with left mousebutton
    if (input->GetMouseButtonPress(MOUSEB_LEFT))
        SpawnObject();

    // Check for loading / saving the scene
    if (input->GetKeyPress(KEY_F5))
    {
        File saveFile(context_, GetSubsystem<FileSystem>()->GetProgramDir() + "Data/Scenes/Ragdolls.xml", FILE_WRITE);
        scene_->SaveXML(saveFile);
    }
    if (input->GetKeyPress(KEY_F7))
    {
        File loadFile(context_, GetSubsystem<FileSystem>()->GetProgramDir() + "Data/Scenes/Ragdolls.xml", FILE_READ);
        scene_->LoadXML(loadFile);
    }

    // Toggle physics debug geometry with space
    if (input->GetKeyPress(KEY_SPACE))
        drawDebug_ = !drawDebug_;
        
    if (input->GetKeyPress (KEY_U)) {
        massCount++;
        if ( massCount > 5 )
            massCount = 0;
        UpdateMassHud (massCount);
    }

    if (input->GetKeyPress (KEY_I)) {
        speedCount++;
        if ( speedCount> 5 )
            speedCount = 0;
        UpdateSpeedHud (speedCount);
    }

    if (input->GetKeyPress (KEY_O)) {
        sizeCount++;
        if ( sizeCount > 5 )
            sizeCount = 0;
        UpdateSizeHud (sizeCount);
    }

    if (input->GetKeyPress (KEY_P)) {
        if ( bulletArc == 0.0 )
            bulletArc = 0.25f;
        else if ( bulletArc > 0.0 )
            bulletArc = 0.0f;
    }

    if (input->GetKeyPress (KEY_R)) {
        RestartJacks ();
    }

    UpdateFps ();
    CleanUpSome ();

}

void Ragdolls::SpawnObject()
{
    ResourceCache* cache = GetSubsystem<ResourceCache>();

    Node* boxNode = scene_->CreateChild("Sphere");
    boxNode->SetPosition(cameraNode_->GetPosition());
    boxNode->SetRotation(cameraNode_->GetRotation());
    boxNode->SetScale(bulletSize[sizeCount]);
    StaticModel* boxObject = boxNode->CreateComponent<StaticModel>();
    boxObject->SetModel(cache->GetResource<Model>("Models/Sphere.mdl"));
    boxObject->SetMaterial(cache->GetResource<Material>("Materials/StoneSmall.xml"));
    boxObject->SetCastShadows(true);

    RigidBody* body = boxNode->CreateComponent<RigidBody>();
    body->SetMass(bulletMass[massCount]);
    body->SetRollingFriction(0.15f);
    CollisionShape* shape = boxNode->CreateComponent<CollisionShape>();
    shape->SetSphere(1.0f);

    const float OBJECT_VELOCITY = bulletSpeed[speedCount];

    // Set initial velocity for the RigidBody based on camera forward vector. Add also a slight up component
    // to overcome gravity better
    body->SetLinearVelocity(cameraNode_->GetRotation() * Vector3(0.0f, bulletArc, 1.0f) * OBJECT_VELOCITY);
}

void Ragdolls::SubscribeToEvents()
{
    // Subscribe HandleUpdate() function for processing update events
    SubscribeToEvent(E_UPDATE, ATOMIC_HANDLER(Ragdolls, HandleUpdate));

    // Subscribe HandlePostRenderUpdate() function for processing the post-render update event, during which we request
    // debug geometry
    SubscribeToEvent(E_POSTRENDERUPDATE, ATOMIC_HANDLER(Ragdolls, HandlePostRenderUpdate));
}

void Ragdolls::HandleUpdate(StringHash eventType, VariantMap& eventData)
{
    using namespace Update;

    // Take the frame time step, which is stored as a float
    float timeStep = eventData[P_TIMESTEP].GetFloat();

    // Move the camera, scale movement with time step
    MoveCamera(timeStep);
}

void Ragdolls::HandlePostRenderUpdate(StringHash eventType, VariantMap& eventData)
{
    // If draw debug mode is enabled, draw physics debug geometry. Use depth test to make the result easier to interpret
    if (drawDebug_)
        scene_->GetComponent<PhysicsWorld>()->DrawDebugGeometry(true);
}

    // support for 2D hud and new features
void Ragdolls::CreateHUD()
{
     float hscal = 0.4f;
    //
    // create a 2nd viewport and scene for a hud with sprites.
    //
    hudScene = new Scene(context_);
    hudScene->CreateComponent<Octree>();
    // Create camera node
    Node* hudCam = hudScene->CreateChild("HudCamera");
    // Set camera's position
    hudCam->SetPosition( Vector3(0.0f, 0.0f, -10.0f));
    hudCamera = hudCam->CreateComponent<Camera>();
    hudCamera->SetOrthographic(true);
    Graphics* graphics = GetSubsystem<Graphics>();
    hudCamera->SetOrthoSize ((float)graphics->GetHeight () * 0.01f ); //PIXEL_SIZE

    ResourceCache *cache = GetSubsystem<ResourceCache>();

    // add a crosshair in the center of the screen
    Sprite2D* sprite = cache->GetResource<Sprite2D>("Textures/NinjaSnowWar/Sight.png");
    Node* targetSprite_ = hudScene->CreateChild("targetSprite");
    targetSprite_->SetPosition2D(Vector2(0,0));
    targetSprite_->SetScale2D(Vector2(0.75f, 0.75f));
    StaticSprite2D* staticSprite = targetSprite_->CreateComponent<StaticSprite2D>();
    staticSprite->SetSprite(sprite);   // Set sprite
    staticSprite->SetBlendMode( BLEND_ALPHA ); // Set blend mode
    staticSprite->SetAlpha(0.3f);  

    // borrow the spinning coin from the 2DSprite example to show what the possibilities are
    float halfWidth = graphics->GetWidth() * 0.5f * 0.01;
    float halfHeight = graphics->GetHeight() * 0.5f * 0.01;
    // Get animation set
    AnimationSet2D* animationSet = cache->GetResource<AnimationSet2D>("Urho2D/GoldIcon.scml");
    if (animationSet == NULL) return;
    Node* spriteNode2 = hudScene->CreateChild("AnimatedSprite2D");
    AnimatedSprite2D* animatedSprite = spriteNode2->CreateComponent<AnimatedSprite2D>();
    animatedSprite->SetAnimationSet(animationSet);         // Set animation
    animatedSprite->SetAnimation("idle", LM_DEFAULT);
    spriteNode2->SetPosition2D( Vector2(halfWidth - 0.4f, halfHeight - 0.4f));

    // (bullet) mass, speed size feature huds
    filler.Push ( cache->GetResource<Sprite2D>("Textures/hudfill1.png") );
    filler.Push ( cache->GetResource<Sprite2D>("Textures/hudfill2.png") );
    filler.Push ( cache->GetResource<Sprite2D>("Textures/hudfill3.png") );
    filler.Push ( cache->GetResource<Sprite2D>("Textures/hudfill4.png") );
    filler.Push ( cache->GetResource<Sprite2D>("Textures/hudfill5.png") );
    filler.Push ( cache->GetResource<Sprite2D>("Textures/hudfill6.png") );

    Sprite2D* spritem = cache->GetResource<Sprite2D>("Textures/hudmass.png");
    Node* hudm = hudScene->CreateChild("hudMass");
    hudm->SetScale2D( Vector2(hscal,hscal));
    hudm->SetPosition2D( Vector2( 0 - (halfWidth/3.0), halfHeight - 0.4)); 
    StaticSprite2D* hudSpritem = hudm->CreateComponent<StaticSprite2D>();
    hudSpritem->SetSprite(spritem);
    hudSpritem->SetAlpha(0.9);
    hudSpritem->SetBlendMode( BLEND_ALPHA);
    hudSpritem->SetOrderInLayer(3); 
    Node* hudfm = hudm->CreateChild("hudMassFill");
    hudfm->SetScale2D( Vector2(1,1));
    hudfm->SetPosition2D(  Vector2( 0, 0)); 
    StaticSprite2D* hudSpritefm = hudfm->CreateComponent<StaticSprite2D>();
    hudSpritefm->SetSprite(filler[0]);
    hudSpritefm->SetAlpha(0.9);
    hudSpritefm->SetBlendMode( BLEND_ALPHA);
    hudSpritefm->SetOrderInLayer(-3); 

    Sprite2D* sprites = cache->GetResource<Sprite2D>("Textures/hudspeed.png");
    Node* huds = hudScene->CreateChild("hudSpeed");
    huds->SetScale2D( Vector2(hscal,hscal));
    huds->SetPosition2D(  Vector2( 0, halfHeight - 0.4)); 
    StaticSprite2D* hudSprites = huds->CreateComponent<StaticSprite2D>();
    hudSprites->SetSprite(sprites);
    hudSprites->SetAlpha(0.9);
    hudSprites->SetBlendMode( BLEND_ALPHA);
    hudSprites->SetOrderInLayer(3); 
    Node* hudsm = huds->CreateChild("hudSpeedFill");
    hudsm->SetScale2D( Vector2(1,1));
    hudsm->SetPosition2D( Vector2( 0, 0)); 
    StaticSprite2D* hudSpritesm = hudsm->CreateComponent<StaticSprite2D>();
    hudSpritesm->SetSprite(filler[0]);
    hudSpritesm->SetAlpha(0.9);
    hudSpritesm->SetBlendMode( BLEND_ALPHA);
    hudSpritesm->SetOrderInLayer(-3); 

    Sprite2D* spritez = cache->GetResource<Sprite2D>("Textures/hudsize.png");
    Node* hudz = hudScene->CreateChild("hudSize");
    hudz->SetScale2D( Vector2(hscal,hscal));
    hudz->SetPosition2D(  Vector2( 0 + (halfWidth/3.0), halfHeight - 0.4)); 
    StaticSprite2D* hudSpritez = hudz->CreateComponent<StaticSprite2D>();
    hudSpritez->SetSprite(spritez);
    hudSpritez->SetAlpha(0.9);
    hudSpritez->SetBlendMode( BLEND_ALPHA);
    hudSpritez->SetOrderInLayer(3); 
    Node* hudzm = hudz->CreateChild("hudSizeFill");
    hudzm->SetScale2D( Vector2(1,1));
    hudzm->SetPosition2D( Vector2( 0, 0)); 
    StaticSprite2D* hudSpritezm = hudzm->CreateComponent<StaticSprite2D>();
    hudSpritezm->SetSprite(filler[0]);
    hudSpritezm->SetAlpha(0.9);
    hudSpritezm->SetBlendMode( BLEND_ALPHA);
    hudSpritezm->SetOrderInLayer(-3);
}

void Ragdolls::RestartJacks()
{
    PODVector< Node * >allnodes;
    scene_->GetChildren (allnodes, true);

    for ( int ii=0; ii<allnodes.Size() ; ii++ ) 
    { 
        if ( allnodes[ii]->GetName().Compare ("Sphere") == 0) allnodes[ii]->Remove ();
        else if ( allnodes[ii]->GetName().Compare ("Stuffing") == 0 ) allnodes[ii]->Remove ();
        else if ( allnodes[ii]->GetName().Compare ("Jack") == 0 ) allnodes[ii]->Remove ();
    }

    ResourceCache *cache = GetSubsystem<ResourceCache>();
    // Create animated models, you dont know ... jack
   for (int z = -1; z <= 1; ++z)
    {
        for (int x = -4; x <= 4; ++x)
        {
            Node* modelNode = scene_->CreateChild("Jack");
            modelNode->SetPosition(Vector3(x * 5.0f, 0.0f, z * 5.0f));
            modelNode->SetRotation(Quaternion(0.0f, 180.0f, 0.0f));
            AnimatedModel* modelObject = modelNode->CreateComponent<AnimatedModel>();
            modelObject->SetModel(cache->GetResource<Model>("Models/Jack.mdl"));
            modelObject->SetMaterial(cache->GetResource<Material>("Materials/Jack.xml"));
            modelObject->SetCastShadows(true);
            // Set the model to also update when invisible to avoid staying invisible when the model should come into
            // view, but does not as the bounding box is not updated
            modelObject->SetUpdateInvisible(true);

            // Create a rigid body and a collision shape. These will act as a trigger for transforming the
            // model into a ragdoll when hit by a moving object
            RigidBody* body = modelNode->CreateComponent<RigidBody>();
            // The Trigger mode makes the rigid body only detect collisions, but impart no forces on the
            // colliding objects
            body->SetTrigger(true);
            CollisionShape* shape = modelNode->CreateComponent<CollisionShape>();
            // Create the capsule shape with an offset so that it is correctly aligned with the model, which
            // has its origin at the feet
            shape->SetCapsule(0.7f, 2.0f, Vector3(0.0f, 1.0f, 0.0f));

            // Create a custom component that reacts to collisions and creates the ragdoll
            modelNode->CreateComponent<CreateRagdoll>();
        }
    }    
}

void Ragdolls::CleanUpSome()
{
    Node* cam = cameraNode_; // note - the camera isnt in the scene
    if ( cam == NULL )
        return;

    PODVector< Node * >allnodes;
    scene_->GetChildren (allnodes, true);
    for ( int ii=0; ii<allnodes.Size() ; ii++ ) 
    { 
        if ( allnodes[ii]->GetName().Compare ("Sphere") == 0 ) 
        {
            if (( allnodes[ii]->GetWorldPosition() - cam->GetWorldPosition() ).Length() > 270.0f)
            {
                allnodes[ii]->Remove ();
            }
        }
    }    
}

void Ragdolls::UpdateFps ()
{
    Engine* eng = GetSubsystem<Engine>();
    String mystr = "FPS: " + String(eng->GetFps());
    mystr += "\nUse WASD keys and mouse/touch to move\n";
    mystr += "LMB to spawn physics objects\n";
    mystr += "U=Mass, I=Speed, O=Size, R=Restart\n";
    mystr += "Space to toggle physics debug geometry";
    SetInstructions ( mystr );
}

void Ragdolls::UpdateMassHud ( int value )
{
    Node* xNode = hudScene->GetChild("hudMass", true);
    if (xNode) {
        Node* fillx = xNode->GetChild("hudMassFill");
        if (fillx) {
            StaticSprite2D* hudSprite = fillx->GetComponent<StaticSprite2D>();
            hudSprite->SetSprite(filler[value]);
        }
    }
}

void Ragdolls::UpdateSpeedHud ( int value )
{
    Node* xNode = hudScene->GetChild("hudSpeed", true);
    if (xNode) {
        Node* fillx = xNode->GetChild("hudSpeedFill");
        if (fillx) {
            StaticSprite2D* hudSprite = fillx->GetComponent<StaticSprite2D>();
            hudSprite->SetSprite(filler[value]);
        }
    }
}

void Ragdolls::UpdateSizeHud ( int value )
{
    Node* xNode = hudScene->GetChild("hudSize", true);
    if (xNode) {
        Node* fillx = xNode->GetChild("hudSizeFill");
        if (fillx) {
            StaticSprite2D* hudSprite = fillx->GetComponent<StaticSprite2D>();
            hudSprite->SetSprite(filler[value]);
        }
    }
}