class NiceInteraction extends Interaction
    dependson(NicePack)
    dependson(NiceAbilityManager);

#exec OBJ LOAD FILE=KillingFloorHUD.utx
#exec OBJ LOAD FILE=KillingFloor2HUD.utx

var NicePack NicePackMutator;
var Material bleedIcon, poisonIcon;
var Texture greenBar, redBar;
var Texture shield;
var float size;
// Weapon box sizes
var float   InventoryBoxWidth;
var float   InventoryBoxHeight;
var float   BorderSize;

// weapons list for `MultiTasker` skill
struct WeaponProgressDisplay
{
    var class<NiceWeapon>   weapClass;
    var float               progress;
    var bool                bShowCounter;
    var int                 counter;
};
var array<WeaponProgressDisplay> niceWeapProgressSet;

event NotifyLevelChange()
{
   Master.RemoveInteraction(self);
}

function RegisterMutator(NicePack activePack)
{
   NicePackMutator = activePack;
}

final private function bool bIsPoisoned(NiceHumanPawn pwn)
{
   local Inventory I;

   if (pwn.Inventory != none)
   {
      for (I = pwn.Inventory; I != none; I = I.Inventory)
      {
         if (I.IsA('MeanPoisonInventory'))
            return true;
      }
   }
   return false;
}

final private function bool bIsBleeding(NiceHumanPawn pwn)
{
   local Inventory I;

   if (pwn.Inventory != none)
   {
      for (I = pwn.Inventory; I != none; I = I.Inventory)
      {
         if (I.IsA('MeanBleedInventory'))
            return true;
      }
   }
   return false;
}

final private function UpdateNiceWeapProgressSet(NiceHumanPawn pwn)
{
    local Inventory I;
    local NiceWeapon niceWeap;
    local WeaponProgressDisplay newProgress;

    // clean this!
    niceWeapProgressSet.Length = 0;

    if (pwn.Inventory != none)
    {
        for (I = pwn.Inventory; I != none; I = I.Inventory)
        {
            niceWeap = NiceWeapon(I);
            if (niceWeap != none && niceWeap != pwn.weapon && !niceWeap.IsMagazineFull())
            {
                newProgress.weapClass = niceWeap.class;
                newProgress.progress = niceWeap.holsteredCompletition;
                newProgress.bShowCounter = true;
                newProgress.counter = niceWeap.GetMagazineAmmo();

                niceWeapProgressSet[niceWeapProgressSet.Length] = newProgress;
            }
        }
    }
}

function PostRender(Canvas C)
{
    local int i;
    local NicePack niceMutator;
    local NiceHumanPawn nicePawn;
    local class<NiceVeterancyTypes> niceVet;
    local NiceWeapon niceWeap;
    local NicePlayerController nicePlayer;
    local ScrnHUD scrnHUDInstance;
    // TODO maybe use scrnhud?
    //  local HUDKillingFloor kfHud;
    local Texture barTexture;
    local int x, y, center, barWidth, offset;
    local int missesWidth, missesHeight, missesSpace;
    local int missesX, missesY;
    local TeamInfo team;
    local int healthToGive, totalExpectedHealth;
    local float textWidth, textHeight;
    local string textToDraw;
    //  local Vector CamPos, ViewDir;
    //  local Rotator CamRot;
    //  local float OffsetX, BarLength, BarHeight, XL, YL, posY;

    if (C == none || C.ViewPort == none || C.ViewPort.Actor == none || C.ViewPort.Actor.Pawn == none)
        return;

    nicePlayer = NicePlayerController(C.ViewPort.Actor.Pawn.Controller);
    niceWeap = NiceWeapon(C.ViewPort.Actor.Pawn.Weapon);
    if (nicePlayer == none)
       return;

    nicePawn = NiceHumanPawn(nicePlayer.pawn);

    //// Draw bleed and poison icons for OWNER
    offset = 4;
    // BLEED!!!
    if (bIsBleeding(nicePawn))
    {
        x = C.ClipX * 0.007;
        y = C.ClipY * 0.93 - size * offset;
        C.SetPos(x, y);
        C.DrawTile(bleedIcon, size, size, 0, 0, bleedIcon.MaterialUSize(), bleedIcon.MaterialVSize());
    }
    offset++;
    // POISON!!!
    if (bIsPoisoned(nicePawn))
    {
        x = C.ClipX * 0.007;
        y = C.ClipY * 0.93 - size * offset;
        C.SetPos(x, y);
        C.DrawTile(poisonIcon, size, size, 0, 0, poisonIcon.MaterialUSize(), poisonIcon.MaterialVSize());
    }

    // TODO draw bleed and poison icons for TEAMMATES
    // C.GetCAmeraLocation(CamPos, CamRot);
    // ViewDir = vector(CamRot);
    // kfHud = HUDKillingFloor(ViewportOwner.Actor.myHUD);
    // OffsetX = (36.f * kfHud.default.VeterancyMatScaleFactor * 0.6) - (kfHud.default.HealthIconSize + 2.0);
    // BarLength = FMin(kfHud.default.BarLength * (float(C.SizeX) / 1024.f), kfHud.default.BarLength);
    // BarHeight = FMin(kfHud.default.BarHeight * (float(C.SizeX) / 1024.f), kfHud.default.BarHeight);
    // for (i = 0; i < kfHUD.PlayerInfoPawns.Length; i++)
    // {
    //     if (kfHUD.PlayerInfoPawns[i].Pawn != none && kfHUD.PlayerInfoPawns[i].Pawn.Health > 0 && 
    //                 (kfHUD.PlayerInfoPawns[i].Pawn.Location - kfHUD.PawnOwner.Location) dot ViewDir > 0.8 &&
    //                 kfHUD.PlayerInfoPawns[i].RendTime > ViewportOwner.Actor.Level.TimeSeconds)
    //     {
    //     C.StrLen(Left(kfHUD.PlayerInfoPawns[i].Pawn.PlayerReplicationInfo.PlayerName, 16), XL, YL);
    //     if (kfHUD.PlayerInfoPawns[i].Pawn.ShieldStrength <= 0)
    //     {
    //         posY = (kfHUD.PlayerInfoPawns[i].PlayerInfoScreenPosY - YL) - 2.75 * BarHeight -
    //                         kfHUD.default.ArmorIconSize * 0.5;
    //     }
    //     else
    //     {
    //         posY = (kfHUD.PlayerInfoPawns[i].PlayerInfoScreenPosY - YL) - 3.8 * BarHeight -
    //                         kfHUD.default.ArmorIconSize * 0.5;
    //     }
    //     offset = 0;

    //     if (bIsBleeding(ScrnHumanPawn(kfHUD.PlayerInfoPawns[i].Pawn)))
    //     {
    //         C.SetPos(kfHUD.PlayerInfoPawns[i].PlayerInfoScreenPosX - OffsetX - 0.15 * BarLength - 
    //                         kfHUD.default.ArmorIconSize - 2.0, posY);
    //         C.DrawTileScaled(bleedIcon, 0.1875, 0.1875);
    //     }
    //     if (bIsPoisoned(ScrnHumanPawn(kfHUD.PlayerInfoPawns[i].Pawn)))
    //     {
    //         C.SetPos(kfHUD.PlayerInfoPawns[i].PlayerInfoScreenPosX - OffsetX + 0.15 * BarLength -
    //                         kfHUD.default.ArmorIconSize - 2.0, posY);
    //         C.DrawTileScaled(poisonIcon, 0.1875, 0.1875);
    //     }
    //     }
    // }

    //// Draw weapons progress bars
    // at first update weapon info
    UpdateNiceWeapProgressSet(nicePawn);

    if (nicePawn != none && class'NiceVeterancyTypes'.static.hasSkill(nicePlayer, class'NiceSkillEnforcerMultitasker')
        && nicePlayer.bFlagDisplayWeaponProgress && niceWeapProgressSet.length > 0)
    {
        x = C.ClipX - InventoryBoxWidth * C.ClipX - 5;
        y = C.ClipY * 0.5 - 0.5 * (InventoryBoxHeight * C.ClipX + 4) * niceWeapProgressSet.Length;

        for (i = 0; i < niceWeapProgressSet.Length; i++)
        {
            DrawWeaponProgress(C, niceWeapProgressSet[i], x, y, nicePawn.PlayerReplicationInfo.Team);
            y += (InventoryBoxHeight * C.ClipX + 4);
        }
    }

    scrnHUDInstance = ScrnHUD(nicePlayer.myHUD);

    if (niceWeap != none && niceWeap.bShowSecondaryCharge && scrnHUDInstance != none)
    {
        C.ColorModulate.X = 1;
        C.ColorModulate.Y = 1;
        C.ColorModulate.Z = 1;
        C.ColorModulate.W = scrnHUDInstance.HudOpacity / 255;
        if (!scrnHUDInstance.bLightHud)
            scrnHUDInstance.DrawSpriteWidget(C, scrnHUDInstance.SecondaryClipsBG);
        scrnHUDInstance.DrawSpriteWidget(C, scrnHUDInstance.SecondaryClipsIcon);
        scrnHUDInstance.SecondaryClipsDigits.value = niceWeap.secondaryCharge;
        scrnHUDInstance.DrawNumericWidget(C, scrnHUDInstance.SecondaryClipsDigits, scrnHUDInstance.DigitsSmall);
    }

    //// Draw invincibility bar
    if (nicePawn != none && nicePawn.invincibilityTimer != 0.0)
    {
        C.SetDrawColor(255, 255, 255);
        if (nicePawn.invincibilityTimer > 0)
            barTexture = greenBar;
        else
            barTexture = redBar;
        center = C.ClipX * 0.5;
        y = C.ClipY * 0.75;
        barWidth = C.ClipX * 0.2;
        niceVet = class'NiceVeterancyTypes'.static.
            GetVeterancy(nicePawn.PlayerReplicationInfo);
        if (niceVet != none)
        {
            if (nicePawn.invincibilityTimer > 0)
                barWidth *= nicePawn.invincibilityTimer / niceVet.static.GetInvincibilityDuration(nicePawn.KFPRI);
            else
               barWidth *= nicePawn.invincibilityTimer / class'NiceSkillZerkGunzerker'.default.cooldown;
        }
        else
            barWidth = 0;

        x = center - (barWidth / 2);
        C.SetPos(x, y);
        C.DrawTile(barTexture, barWidth, 32, 0, 0, barTexture.MaterialUSize(), barTexture.MaterialVSize());
        if (nicePawn.safeMeleeMisses > 0)
        {
            missesSpace = 10; // 64x64 => 16x16
            missesHeight = 16;
            missesWidth = nicePawn.safeMeleeMisses * 16 + (nicePawn.safeMeleeMisses - 1) * missesSpace;
            missesX = center - (missesWidth / 2);
            missesY = y + (32 - missesHeight) * 0.5;

            for (i = 0; i < nicePawn.safeMeleeMisses; i++)
            {
                C.SetPos(missesX + i * (16 + missesSpace), missesY);
                C.DrawTile(shield, 16, 16, 0, 0, shield.MaterialUSize(), shield.MaterialVSize());
            }
        }
    }

    //// Draw quad damage bar
    if (nicePawn != none && nicePawn.quadDamageRemaining > 0.0)
    {
        C.SetDrawColor(255, 255, 255);
        barTexture = redBar;
        center = C.ClipX * 0.5;
        y = C.ClipY * 0.45;
        barWidth = C.ClipX * 0.2;
        barWidth *= nicePawn.quadDamageRemaining / class'NiceSkillEnforcerBruteA'.default.maximumDamageAdded;
        x = center - (barWidth / 2);
        C.SetPos(x, y);
        Log("DRAWING" @ x @ y @ barWidth);
        C.DrawTile(barTexture, barWidth, 32, 0, 0, barTexture.MaterialUSize(), barTexture.MaterialVSize());
    }//native(466) final function DrawTile( material Mat, float XL, float YL, float U, float V, float UL, float VL );

    team = C.ViewPort.Actor.Pawn.PlayerReplicationInfo.Team;
    //// Draw health still in regen timer
    healthToGive = ScrnHumanPawn(C.ViewPort.Actor.Pawn).clientHealthToGive;
    if (healthToGive > 0) {
        totalExpectedHealth = healthToGive + C.ViewPort.Actor.Pawn.health;;
        C.Font = class'ROHUD'.Static.LoadSmallFontStatic(3);
        if (totalExpectedHealth >= C.ViewPort.Actor.Pawn.healthMax) {
            if(team.teamIndex == 0) {
                C.SetDrawColor(255, 64, 64);
            }
            else {
                C.SetDrawColor(
                    team.teamColor.R,
                    team.teamColor.G,
                    team.teamColor.B);
            }
        }
        else {
            C.SetDrawColor(128, 128, 128);
        }
        textToDraw = "+" $ healthToGive;
        C.TextSize(textToDraw, textWidth, textHeight);
        C.SetPos(C.ClipX * 0.05, C.ClipY * 0.9);
        C.DrawText(textToDraw);
    }

    ////  Draw cooldowns
    if (nicePlayer.abilityManager == none)
       return;
    for (i = 0; i < nicePlayer.abilityManager.currentAbilitiesAmount; i++)
       DrawAbilityCooldown(C, i);

    //// Draw counters
    niceMutator = class'NicePack'.static.Myself(nicePawn.Level);

    if (niceMutator != none && nicePlayer != none && nicePlayer.bFlagDisplayCounters)
    {
        x = C.ClipX * 0.5 - (64 + 2) * niceMutator.GetVisibleCountersAmount();
        y = C.ClipY * 0.01;
        for (i = 0; i < niceMutator.niceCounterSet.Length; i++)
        {
            if (niceMutator.niceCounterSet[i].value != 0 || niceMutator.niceCounterSet[i].bShowZeroValue)
            {
                DrawCounter(C, niceMutator.niceCounterSet[i], x, y, team);
                x += 128 + 4;
            }
        }
    }
}

function DrawCounter(Canvas C, NicePack.CounterDisplay counter, int x, int y, TeamInfo team){
    local float borderSpace;
    local Texture textureToDraw;
    local float textWidth, textHeight;
    local string textToDraw;
    // Some per-defined values for drawing
    local int iconSize, backgroundWidth, backgroundHeight;
    // Fill some constants that will dictate how to display counter
    iconSize = 64;
    backgroundWidth = 128;
    backgroundHeight = 64;
    borderSpace = 8;
    // Reset color
    if(team.teamIndex == 0)
       C.SetDrawColor(255, 64, 64);
    else
       C.SetDrawColor(team.teamColor.R, team.teamColor.G, team.teamColor.B);
    // Draw background
    C.SetPos(x, y);
    textureToDraw = Texture(class'HUDKillingFloor'.default.HealthBG.WidgetTexture);
    C.DrawTile(textureToDraw, 128, 64, 0, 0, textureToDraw.MaterialUSize(), textureToDraw.MaterialVSize());
    // Draw appropriate icon
    C.SetPos(x + borderSpace, y + borderSpace);
    textureToDraw = counter.icon;
    C.DrawTile(textureToDraw, 64 - 2*borderSpace, 64 - 2 * borderSpace, 0, 0,
       textureToDraw.MaterialUSize(), textureToDraw.MaterialVSize());
    // Draw numbers
    textToDraw = string(counter.value);
    C.Font = class'ROHUD'.Static.LoadSmallFontStatic(1);
    C.TextSize(textToDraw, textWidth, textHeight);
    C.SetPos(x + iconSize + (backgroundWidth - iconSize - textWidth) / 2, y + (backgroundHeight - textHeight) / 2 + 2);
    C.DrawText(textToDraw);
}
function DrawAbilityCooldown(Canvas C, int abilityIndex){
    local Texture skillTexture, backgroundTexture;
    local NiceHumanPawn nicePawn;
    local NicePlayerController nicePlayer;
    local class<NiceVeterancyTypes> niceVet;
    local int x, y;
    local string textToDraw;
    local float textWidth, textHeight;
    local NiceAbilityManager.EAbilityState abilityState;
    if(C == none) return;
    if(C.ViewPort == none) return;
    if(C.ViewPort.Actor == none) return;
    nicePawn = NiceHumanPawn(C.ViewPort.Actor.Pawn);
    nicePlayer = NicePlayerController(C.ViewPort.Actor.Pawn.Controller);
    if(nicePawn == none)
       return;
    if(nicePlayer == none || nicePlayer.abilityManager == none)
       return;
    niceVet = class'NiceVeterancyTypes'.static.GetVeterancy(nicePawn.KFPRI);
    skillTexture =
       nicePlayer.abilityManager.currentAbilities[abilityIndex].
       description.icon;
    if(skillTexture == none)
       return;
    // Set stuff up
    x = C.ClipX * 0.265;
    x += abilityIndex * (10 + 64);
    y = C.ClipY * 0.93;
    textToDraw = string(int(Ceil(nicePlayer.abilityManager.currentAbilities[abilityIndex].cooldown)));
    backgroundTexture = Texture'KillingFloorHUD.HUD.Hud_Box_128x64';
    // Reset color
    C.SetDrawColor(255, 64, 64);
    // Draw background
    C.SetPos(x, y);
    C.DrawTile(backgroundTexture, 64, 64, 0, 0, backgroundTexture.MaterialUSize(), backgroundTexture.MaterialVSize());
    C.SetPos(x, y);
    C.DrawTile(skillTexture, 64, 64, 0, 0, skillTexture.MaterialUSize(), skillTexture.MaterialVSize());
    //  Draw additional background
    abilityState =
       nicePlayer.abilityManager.currentAbilities[abilityIndex].myState;
    if(abilityState == ASTATE_ACTIVE)
       C.SetDrawColor(255, 0, 0, 128);
    if(abilityState == ASTATE_COOLDOWN)
       C.SetDrawColor(0, 0, 0, 192);
    if(abilityState != ASTATE_READY){
       C.SetPos(x, y);
       C.DrawTileStretched(Material'KillingFloorHUD.HUD.WhiteTexture', 64, 64);
    }
    //  Draw cooldown stuff
    if(abilityState == ASTATE_COOLDOWN){
       C.SetDrawColor(255, 192, 192);
       C.Font = class'ROHUD'.static.LoadSmallFontStatic(1);
       C.TextSize(textToDraw, textWidth, textHeight);
       C.SetPos(x, y);
       C.SetPos(x + (64 - textWidth) / 2, y + (64 - textHeight) / 2 + 2);
       C.DrawText(textToDraw);
    }
    //  Draw calibration GUI
    DrawCalibrationStars(C);
}
function DrawCalibrationStars(Canvas C){
    local Texture starTexture;
    local int x, y, i;
    local int starsAmount;
    local NiceHumanPawn nicePawn;
    local NicePlayerController nicePlayer;
    if(C == none) return;
    if(C.ViewPort == none) return;
    if(C.ViewPort.Actor == none) return;
    nicePawn = NiceHumanPawn(C.ViewPort.Actor.Pawn);
    if(nicePawn == none)
       return;
    if(nicePawn.currentCalibrationState == CALSTATE_NOABILITY)
       return;
    nicePlayer = NicePlayerController(nicePawn.controller);
    if(nicePlayer == none)
       return;
    starsAmount = nicePawn.calibrationScore;
    x = C.ClipX * 0.5;
    x -= 0.5 * (starsAmount * 32 + (starsAmount - 1) * 16);
    if(nicePawn.currentCalibrationState == CALSTATE_ACTIVE)
       y = C.ClipY * 0.6;
    else
       y = C.ClipY * 0.02;
    starTexture = Texture'KillingFloorHUD.HUD.Hud_Perk_Star';
    for(i = 0;i < starsAmount;i ++){
       C.SetPos(x, y);
       C.SetDrawColor(255, 255, 255);
       C.DrawTile(starTexture, 32, 32, 0, 0, starTexture.MaterialUSize(), starTexture.MaterialVSize());
       x += 32 + 16;
    }
}

function DrawWeaponProgress(Canvas C, WeaponProgressDisplay weapProgress, int x, int y, TeamInfo team)
{
    local float textWidth, textHeight;
    local string textToDraw;
    local float TempWidth, TempHeight, TempBorder;

    TempWidth   = InventoryBoxWidth * C.ClipX;
    TempHeight  = InventoryBoxHeight * C.ClipX;
    TempBorder  = BorderSize * C.ClipX;
    // Draw background bar
    if (team.teamIndex == 0)
       C.SetDrawColor(255, 64, 64, 64);
    else
       C.SetDrawColor(team.teamColor.R, team.teamColor.G, team.teamColor.B, 64);
    C.SetPos(x, y);
    C.DrawTile(Texture'Engine.WhiteSquareTexture', TempWidth * weapProgress.progress, TempHeight, 0, 0, 2, 2);
    // Draw this item's Background
    if(team.teamIndex == 0)
       C.SetDrawColor(255, 64, 64);
    else
       C.SetDrawColor(team.teamColor.R, team.teamColor.G, team.teamColor.B);
    C.SetPos(x, y);
    C.DrawTileStretched(Texture'KillingFloorHUD.HUD.HUD_Rectangel_W_Stroke', TempWidth, TempHeight);
    // Draw the Weapon's Icon over the Background
    C.SetDrawColor(255, 255, 255);
    C.SetPos(x + TempBorder, y + TempBorder);
    if(weapProgress.weapClass.default.HudImage != none)
       C.DrawTile(weapProgress.weapClass.default.HudImage,
           TempWidth - (2.0 * TempBorder), TempHeight - (2.0 * TempBorder), 0, 0, 256, 192);
    // Draw counter, if needed
    if(team.teamIndex == 0)
       C.SetDrawColor(255, 64, 64);
    else
       C.SetDrawColor(team.teamColor.R, team.teamColor.G, team.teamColor.B);
    if(weapProgress.bShowCounter)
    {
       textToDraw = string(weapProgress.counter);
       C.Font = class'ROHUD'.Static.LoadSmallFontStatic(5);
       C.TextSize(textToDraw, textWidth, textHeight);
       C.SetPos(x + TempWidth - TempBorder - textWidth, y + TempHeight - TempBorder - textHeight + 2);
       C.DrawText(textToDraw);
    }
}

function bool KeyEvent(EInputKey Key, EInputAction Action, float Delta)
{
    local bool bNeedsReload;
    local string Alias, LeftPart, RigthPart;
    local NiceWeapon niceWeap;
    local NicePlayerController nicePlayer;

    // Find controller and current weapon
    nicePlayer = NicePlayerController(ViewportOwner.Actor);
    if (nicePlayer == none)
       return false;
    if (nicePlayer.Pawn != none)
       niceWeap = NiceWeapon(nicePlayer.Pawn.Weapon);
    // If this is a button press - detect alias
    if (Action == IST_Press)
    {
       // Check for reload command
       Alias = nicePlayer.ConsoleCommand("KEYBINDING" @ nicePlayer.ConsoleCommand("KEYNAME" @ Key));
       if (nicePlayer.bAdvReloadCheck)
           bNeedsReload = InStr(Caps(Alias), "RELOADMENOW") > -1 || InStr(Caps(Alias), "RELOADWEAPON") > -1;
       if (Divide(Alias, " ", LeftPart, RigthPart))
           Alias = LeftPart;
       if (Key == IK_MouseWheelUp || Key == IK_MouseWheelDown)
       {
           nicePlayer.UpdateSelectors();
           if (nicePlayer.hasZeroSelector && nicePlayer.bUsesMouseWheel && nicePlayer.bNiceWeaponManagement)
           {
               nicePlayer.ScrollSelector(0, nicePlayer.bMouseWheelLoops, Key == IK_MouseWheelUp);
               return true;
           }
       }
    }

    // Open trader on movement if it's a pre-game
    if (NicePackMutator.bIsPreGame && NicePackMutator.bInitialTrader && (NicePackMutator.bStillDuringInitTrader || !nicePlayer.bOpenedInitTrader) && nicePlayer.Pawn != none)
    {
        if (Alias ~= "MoveForward" || Alias ~= "MoveBackward" || Alias ~= "TurnLeft" || Alias ~= "TurnRight"
            || Alias ~= "StrafeLeft" || Alias ~= "StrafeRight" || Alias ~= "Axis")
        {
            // nicePlayer.ClientOpenMenu("NicePack.NiceGUIBuyMenu",,"Test stuff",string(15));
            nicePlayer.ShowBuyMenu("Initial trader", KFHumanPawn(nicePlayer.Pawn).MaxCarryWeight);
            nicePlayer.bOpenedInitTrader = true;
            return true;
        }
    }

    // Reload if we've detected a reload alias in this button's command
    if (niceWeap != none && !nicePlayer.bUseServerReload &&
        (bNeedsReload || Alias ~= "ReloadMeNow" || Alias ~= "ReloadWeapon"))
       niceWeap.ClientReloadMeNow();

    return false;
}

defaultproperties
{
    bleedIcon=Texture'NicePackT.MeanZeds.bleedIcon'
    poisonIcon=Texture'NicePackT.MeanZeds.poisonIcon'
    greenBar=Texture'KFStoryGame_Tex.HUD.Batter_Fill'
    redBar=Texture'KFStoryGame_Tex.HUD.BarFill_Red'
    Shield=Texture'KillingFloorHUD.HUD.Hud_Shield'
    Size=75.599998
    InventoryBoxWidth=0.100000
    InventoryBoxHeight=0.075000
    BorderSize=0.005000
    bVisible=True
}