OST_HUDElement.cpp

// Copyright 1998-2014 Epic Games, Inc. All Rights Reserved.

#include "OST_Game.h"
#include "OST_HUD.h"
#include "OST_HUDElement.h"


AOST_HUDElement::AOST_HUDElement(const class FObjectInitializer& PCIP)
    : Super(PCIP)
{
    Align = EHUDElementsAlign::EBT_CenterCenter;
    Size = FVector2D(100.0f, 40.0f);
}

bool AOST_HUDElement::Init()
{
    if (!MyViewportClient)
    {
        if (!MyHUD)
        {
            UE_LOG(OST_Log, Error, TEXT("%s::Init() -> No MyHUD"),*GetName());
            return false;
        }
        const ULocalPlayer* _localPlayer = Cast<ULocalPlayer>(MyHUD->PlayerOwner->Player);
        MyViewportClient = _localPlayer->ViewportClient;
    }
    OnInit();
    return true;
}

void AOST_HUDElement::SendHUDElementEventName(FName Sender, FName Event)
{
    HUDElementEvent.Broadcast(Sender, Event);
    OnHUDElementEvent(Sender, Event);
}

FVector2D AOST_HUDElement::GetScreenLocation()
{
    return RealLocation;
}

void AOST_HUDElement::SetScreenLocation(FVector2D NewLocation)
{
    LocOffset = NewLocation;
}

void AOST_HUDElement::SetState(TEnumAsByte<EHUDElementsEnum::EElementState> NewState)
{
    /*for (int32 i = 0; i < ChildrenElements.Num(); i++)
    {
        ChildrenElements[i]->State = NewState;
    }*/
    State = NewState;
}

void AOST_HUDElement::SetParent(AActor* NewParent)
{
    Parent = NewParent;
    AOST_HUDElement* _parent = Cast<AOST_HUDElement>(NewParent);
    if (_parent)
    {
        _parent->AddChieldElement(this);
    }
}

FName AOST_HUDElement::GetParentName()
{
    FName _parentName;

    if (!Parent)
    {
        return "noname";
    }

    if (Cast<AOST_HUDElement>(Parent))
    {
        _parentName = Cast<AOST_HUDElement>(Parent)->Name;
    }
    else
    {
        _parentName = FName(*Parent->GetName());
    }
    return _parentName;
}

FName AOST_HUDElement::GetGlobalName(FName LocalName)
{
    return FName(*(GetParentName().ToString() + LocalName.ToString()));
}

AOST_HUDElement* AOST_HUDElement::GetElementByName(FName _name)
{
    AOST_HUD* _myHud = Cast<AOST_HUD>(MyHUD);
    if (!_myHud)
    {
        return NULL;
    }
    for (int32 i = 0; i < _myHud->HUDElementList.Num(); i++)
    {
        if (_myHud->HUDElementList[i]->Name == _name)
        {
            return _myHud->HUDElementList[i];
        }
    }
    return NULL;
}

void AOST_HUDElement::HideElement()
{
    //UE_LOG(OST_Log, Log, TEXT("%s::HideElement()"), *GetName());
    SetState(EHUDElementsEnum::EBT_Hide);
}

void AOST_HUDElement::UnHideElement()
{
    //UE_LOG(OST_Log, Log, TEXT("%s::UnHideElement()"), *GetName());
    SetState(EHUDElementsEnum::EBT_Normal);
}

bool AOST_HUDElement::AddChieldElement(AOST_HUDElement* Element)
{
    if (ChildrenElements.Find(Element) < 0)
    {
        ChildrenElements.Add(Element);
        return true;
    }
    GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, Name.ToString() + "->AddChieldElement() - try double add");
    return false;
}

void AOST_HUDElement::DrawChieldElements()
{
    if (ChildrenElements.Num() < 1) return;
    for (int32 i = 0; i < ChildrenElements.Num(); i++)
    {
        if (ChildrenElements[i]->State != EHUDElementsEnum::EBT_Hide)
        {
            ChildrenElements[i]->DrawHUDElement();
        }
    }
}

FVector2D AOST_HUDElement::GetAlignmentLocation()
{
    FVector2D _startLoc;
    FVector2D _parentSize = FVector2D::ZeroVector;

    AOST_HUDElement* _parent = Cast<AOST_HUDElement>(Parent);

    if (_parent)
    {
        _startLoc = _parent->RealLocation;
        _parentSize = _parent->RealSize;
    }
    else
    {
        _startLoc = FVector2D::ZeroVector;
        if (MyViewportClient)
        {
            MyViewportClient->GetViewportSize(_parentSize);
        }
    }

    FVector2D _result;

    switch (Align)
    {
        case EHUDElementsAlign::EBT_UpCenter:
            _result.X = (_parentSize.X - RealSize.X) / 2;
            _result.Y = 0.0f;
            break;
        case EHUDElementsAlign::EBT_UpRight:
            _result.X = _parentSize.X - RealSize.X;
            _result.Y = 0.0f;
            break;
        case EHUDElementsAlign::EBT_CenterLeft:
            _result.Y = (_parentSize.Y - RealSize.Y) / 2;
            _result.X = 0.0f;
            break;
        case EHUDElementsAlign::EBT_CenterCenter:
            _result.Y = (_parentSize.Y - RealSize.Y) / 2;
            _result.X = (_parentSize.X - RealSize.X) / 2;
            break;
        case EHUDElementsAlign::EBT_CenterRight:
            _result.Y = (_parentSize.Y - RealSize.Y) / 2;
            _result.X = _parentSize.X - RealSize.X;
            break;
        case EHUDElementsAlign::EBT_DownLeft:
            _result.Y = _parentSize.Y - RealSize.Y;
            _result.X = 0.0f;
            break;
        case EHUDElementsAlign::EBT_DownCenter:
            _result.Y = _parentSize.Y - RealSize.Y;
            _result.X = (_parentSize.X - RealSize.X) / 2;
            break;
        case EHUDElementsAlign::EBT_DownRight:
            _result.Y = _parentSize.Y - RealSize.Y;
            _result.X = _parentSize.X - RealSize.X;
            break;
        case EHUDElementsAlign::EBT_UpLeft:
        case EHUDElementsAlign::EBT_None:
        default:
            _result = FVector2D::ZeroVector;
            break;
    }

    return _result + _startLoc;
}

void AOST_HUDElement::DrawDebugInfo(FVector2D _location)
{
    AOST_HUD* _hud = Cast<AOST_HUD>(MyHUD);
    if (_hud)
    {
        FString  _tmpStr = FString::Printf(TEXT("I'm - %s / Children cnt=%i / Scale: %.1f"), *(Name.ToString()),ChildrenElements.Num(), Scale);
        _hud->DrawText(_tmpStr, FLinearColor::Red, _location.X, _location.Y, _hud->DefaultFont, 0.5f);
        _hud->DrawText(FString("My parent is -  ") + ((Cast<AOST_HUDElement>(Parent)) ? Cast<AOST_HUDElement>(Parent)->Name.ToString() : "NULL"), FLinearColor::Red, _location.X, _location.Y + 15, _hud->DefaultFont, 0.5f);
    }
}

void AOST_HUDElement::DrawHUDElement()
{
    if (State == EHUDElementsEnum::EBT_Hide) return;

    OnBeforeDrawHUDElement();

    if (!MyViewportClient)
    {
        UE_LOG(OST_Log, Error, TEXT("%s::DrawHUDElement() -> No MyViewportClient"),*GetName());
        return;
    }

    AOST_HUD* _hud = Cast<AOST_HUD>(MyHUD);

    if (_hud)
    {
        Scale = _hud->GlobalScale;
    }
    else
    {
        Scale = 1.0f;
    }

    RealLocation = GetAlignmentLocation() + LocOffset*Scale;
    RealSize = Size*Scale;

    if (bIsDrugging && MyViewportClient && MyHUD)
    {
        FVector2D _mousePos;

        MyViewportClient->GetMousePosition(_mousePos);
        RealLocation += (_mousePos - MouseLastClickLoc);
    }
    else if (bIsDrugging)
    {
        GEngine->AddOnScreenDebugMessage(-1, 5.f, FColor::Red, "ERROR");
    }

    if (bCanMouseEvents)
    {
        bool _bCreateHitBox = false;
        if (!MyHUD->GetHitBoxWithName(Name)) _bCreateHitBox = true;
        if ((MyHUD->GetHitBoxWithName(Name) && LastLocOffset != RealLocation))  _bCreateHitBox = true;
        if ((MyHUD->GetHitBoxWithName(Name) && RealSize != LastSize))  _bCreateHitBox = true;
        if (_bCreateHitBox)
        {
            MyHUD->AddHitBox(RealLocation, RealSize, Name, true);
            LastLocOffset = RealLocation;
            LastSize = RealSize;
        }
    }

    OnAfterDrawHUDElement();
}

AOST_Character* AOST_HUDElement::GetCharacter()
{
    if (MyHUD && MyHUD->PlayerOwner && MyHUD->PlayerOwner->GetPawn())
    {
        return Cast<AOST_Character>(MyHUD->PlayerOwner->GetPawn());
    }
    return NULL;
}

void AOST_HUDElement::ReceiveActorBeginCursorOver()
{
    if (!bCanMouseEvents) return;

    Super::ReceiveActorBeginCursorOver();

    //UE_LOG(OST_Log, Warning, TEXT("%s::ReceiveActorBeginCursorOver()"), *GetName());

    if (Cast<AOST_HUDElement>(Parent))
    {
        Cast<AOST_HUDElement>(Parent)->ReceiveFromChieldBeginCursorOver(this->Name);
    }
}
void AOST_HUDElement::ReceiveActorEndCursorOver()
{
    if (!bCanMouseEvents) return;

    Super::ReceiveActorEndCursorOver();

    //UE_LOG(OST_Log, Warning, TEXT("%s::ReceiveActorEndCursorOver()"), *GetName());

    if (Cast<AOST_HUDElement>(Parent))
    {
        Cast<AOST_HUDElement>(Parent)->ReceiveFromChieldEndCursorOver(this->Name);
    }
}
void AOST_HUDElement::ReceiveActorOnClicked()
{
    if (!bCanMouseEvents) return;

    Super::ReceiveActorOnClicked();

    //UE_LOG(OST_Log, Warning, TEXT("%s::ReceiveActorOnClicked()"), *GetName());

    if (bDraggable && MyViewportClient)
    {
        MyViewportClient->GetMousePosition(MouseLastClickLoc);
        bIsDrugging = true;
    }

    if (Cast<AOST_HUDElement>(Parent))
    {
        Cast<AOST_HUDElement>(Parent)->ReceiveFromChieldOnClicked(this->Name);
    }
}
void AOST_HUDElement::ReceiveActorOnReleased()
{
    if (!bCanMouseEvents) return;

    Super::ReceiveActorOnReleased();

    if (bDraggable && MyViewportClient)
    {
        bIsDrugging = false;
        FVector2D _mousePos;
        MyViewportClient->GetMousePosition(_mousePos);
        LocOffset += (_mousePos - MouseLastClickLoc);
    }

    if (Cast<AOST_HUDElement>(Parent))
    {
        Cast<AOST_HUDElement>(Parent)->ReceiveFromChieldOnReleased(this->Name);
    }
}

void AOST_HUDElement::DrawTextureSimpleExt(UTexture2D* Texture, FVector2D TXTLocation, FVector2D TXTSize)
{
    if (TXTSize == FVector2D::ZeroVector) return;

    if (!Texture)
    {
        MyHUD->DrawRect(FLinearColor(1, 0, 0, 0.5f), TXTLocation.X, TXTLocation.Y, TXTSize.X, TXTSize.Y);
        DrawMemoText(FString("No image"),FVector2D::ZeroVector, FLinearColor::Yellow, TXTLocation, 10.0f,Cast<AOST_HUD>(MyHUD)->DefaultFont, 0.5f, EHUDElementsAlign::EBT_CenterCenter);
        return;
    }
    float _scale = TXTSize.X / Texture->GetSizeX();
    MyHUD->DrawTextureSimple(Texture, TXTLocation.X, TXTLocation.Y, _scale);
}

void AOST_HUDElement::DrawMemoText(FString Text, FVector2D TextSize, FLinearColor TextColor, FVector2D TextLoc, float LenInterval,
    UFont* Font, float FontScale, TEnumAsByte<EHUDElementsAlign::EElementAlign> TextAlign)
{
    if (Text == "")
    {
        UE_LOG(OST_Log, Error, TEXT("%s::DrawMemoText() - Have no text"), *GetName());
        return;
    }
    if (FontScale == 0.0f)
    {
        UE_LOG(OST_Log, Error, TEXT("%s::DrawMemoText() - FontScale == 0.0f"), *GetName());
        return;
    }

    if (TextSize == FVector2D::ZeroVector)
    {
        int32 _id;
        int32 _lenNum = 0;

        while (_lenNum < 10)
        {
            _id = Text.Find("/", ESearchCase::IgnoreCase, ESearchDir::FromStart, 0);
            if (_id > 0)
            {
                MyHUD->DrawText(Text.Left(_id), TextColor, TextLoc.X, TextLoc.Y + _lenNum*LenInterval, Font, FontScale);
                Text = Text.Right(Text.Len() - _id - 1);
                _lenNum++;
            }
            else
            {
                break;
            }
        }
        MyHUD->DrawText(Text, TextColor, TextLoc.X, TextLoc.Y + _lenNum*LenInterval, Font, FontScale);
        return;
    }

    int32 _strWidth;
    int32 _strHeight;
    Font->GetStringHeightAndWidth(Text, _strHeight, _strWidth);
    _strWidth *= FontScale;
    _strHeight *= FontScale;

    float _charW = _strWidth / Text.Len();
    float _charH = _strHeight;

    int32 _maxCharCntInLen = TextSize.X / _charW;

    int32 _lenMax = TextSize.Y / (_charH + LenInterval);

    FString _strOut = Text;

    for (int32 i = 0; i <= _lenMax; i++)
    {
        MyHUD->DrawText(_strOut.Left(_maxCharCntInLen), TextColor, TextLoc.X, TextLoc.Y + i*(_charH + LenInterval), Font, FontScale);
        _strOut = _strOut.Right(_strOut.Len() - _maxCharCntInLen);
        if (_strOut == "") break;
    }
}

void AOST_HUDElement::ReceiveFromChieldBeginCursorOver(FName _nameChield)
{
    SendHUDElementEventName(_nameChield, "OnBeginCursorOver");
    //UE_LOG(OST_Log, Warning, TEXT("%s::ReceiveFromChieldBeginCursorOver(%s)"), *GetName(), *(_nameChield.ToString()));
    if (Cast<AOST_HUDElement>(Parent))
    {
        Cast<AOST_HUDElement>(Parent)->ReceiveFromChieldBeginCursorOver(_nameChield);
    }
}
void AOST_HUDElement::ReceiveFromChieldEndCursorOver(FName _nameChield)
{
    SendHUDElementEventName(_nameChield, "OnEndCursorOver");
    //UE_LOG(OST_Log, Warning, TEXT("%s::ReceiveFromChieldEndCursorOver(%s)"), *GetName(), *(_nameChield.ToString()));
    if (Cast<AOST_HUDElement>(Parent))
    {
        Cast<AOST_HUDElement>(Parent)->ReceiveFromChieldEndCursorOver(_nameChield);
    }
}
void AOST_HUDElement::ReceiveFromChieldOnClicked(FName _nameChield)
{
    SendHUDElementEventName(_nameChield, "OnClicked");
    //UE_LOG(OST_Log, Warning, TEXT("%s::ReceiveFromChieldOnClicked(%s)"), *GetName(), *(_nameChield.ToString()));
    if (Cast<AOST_HUDElement>(Parent))
    {
        Cast<AOST_HUDElement>(Parent)->ReceiveFromChieldOnClicked(_nameChield);
    }
}
void AOST_HUDElement::ReceiveFromChieldOnReleased(FName _nameChield)
{
    SendHUDElementEventName(_nameChield, "OnReleased");
    //UE_LOG(OST_Log, Warning, TEXT("%s::ReceiveFromChieldOnReleased(%s)"), *GetName(), *(_nameChield.ToString()));
    if (Cast<AOST_HUDElement>(Parent))
    {
        Cast<AOST_HUDElement>(Parent)->ReceiveFromChieldOnReleased(_nameChield);
    }
}

void AOST_HUDElement::SetPlayerController(APlayerController* NewPC)
{
    UE_LOG(OST_Log, Warning, TEXT("%s::SetPlayerController()"), *GetName());
    MyPlayerController = NewPC;
}

APlayerController* AOST_HUDElement::GetPlayerController()
{

    if (!MyPlayerController)
    {
        UWorld* world = GetWorld();
        if (world)
        {
            MyPlayerController = world->GetFirstPlayerController();
        }
    }
    return MyPlayerController;
}