1029 lines
37 KiB
C++
1029 lines
37 KiB
C++
|
// Lot STE, fiches ORG5-I1 et ORG5-I2a (affichage) - voir LPBonusRewardSubsystem.h.
|
||
|
|
// Origine : comportement reconstruit d'apres LifePlay 2023.04 de Vinfamy. Licence MIT
|
||
|
|
// (SPDX-License-Identifier: MIT), texte de reference : Licenses/Vinfamy_License.txt.
|
||
|
|
|
||
|
|
#include "LPBonusRewardSubsystem.h"
|
||
|
|
|
||
|
|
#include "Blueprint/UserWidget.h"
|
||
|
|
#include "Blueprint/WidgetTree.h"
|
||
|
|
#include "Components/CanvasPanelSlot.h"
|
||
|
|
#include "Components/PanelWidget.h"
|
||
|
|
#include "Components/TextBlock.h"
|
||
|
|
#include "Components/VerticalBox.h"
|
||
|
|
#include "Components/VerticalBoxSlot.h"
|
||
|
|
#include "Engine/GameInstance.h"
|
||
|
|
#include "HAL/PlatformTime.h"
|
||
|
|
#include "Kismet/KismetMathLibrary.h"
|
||
|
|
#include "LifePlay.h"
|
||
|
|
#include "Styling/CoreStyle.h"
|
||
|
|
#include "UObject/TextProperty.h"
|
||
|
|
#include "UObject/UnrealType.h"
|
||
|
|
|
||
|
|
namespace LPBonusReward
|
||
|
|
{
|
||
|
|
constexpr float PollSeconds = 0.1f; // sondage H1 (STE-ORG5-SPEC.md 2.2)
|
||
|
|
constexpr double DebounceSeconds = 0.2; // RetriggerableDelay(0.2) de l'auteur (SPEC 1.1 E3)
|
||
|
|
constexpr int32 CandidateCount = 10; // Array_Resize(10) apres Array_Shuffle (SPEC 1.1 E5)
|
||
|
|
constexpr int32 MaxRewards = 3; // NotEqual_IntInt(countBR, 3) (SPEC 1.1 E6e)
|
||
|
|
const TCHAR* const AttractionKey = TEXT("attractiontoplayer");
|
||
|
|
|
||
|
|
// Affichage (fiche ORG5-I2a, STE-ORG5-I2-SPEC.md 2.2 et decisions de l'utilisateur).
|
||
|
|
constexpr double RewardLineSeconds = 20.0; // Q-I2-2 : chaque ligne retiree 20 s apres son affichage
|
||
|
|
constexpr int32 MaxRewardLines = 1; // V-min : une ligne, remplacee a la recompense suivante (SPEC 2.2, V6-3)
|
||
|
|
constexpr double EquipMenuMinHeight = 500.0; // Q-I2-3 : hauteur d'EquipMenu chez l'auteur (SPEC 1.1 A3)
|
||
|
|
constexpr float RewardFontSize = 16.f; // RewardText de l'auteur (SPEC 1.1 A5)
|
||
|
|
constexpr int32 RewardOutlineSize = 2; // idem, contour noir alpha 0,8
|
||
|
|
const TCHAR* const CursorProp = TEXT("Cursor");
|
||
|
|
const TCHAR* const EquipMenuName = TEXT("EquipMenu");
|
||
|
|
const TCHAR* const ActionTextName = TEXT("ActionText");
|
||
|
|
const TCHAR* const RewardBoxName = TEXT("LPBonusRewardBox");
|
||
|
|
|
||
|
|
// Retire une ligne de l'ecran si elle existe encore (pas d'acces apres destruction).
|
||
|
|
void RemoveLine(const FLPBonusRewardLine& Entry)
|
||
|
|
{
|
||
|
|
UTextBlock* Line = Entry.Line.Get();
|
||
|
|
if (IsValid(Line))
|
||
|
|
{
|
||
|
|
Line->RemoveFromParent();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Police de la ligne : copiee d'ActionText (texte voisin dans EquipMenu, SPEC 1.4 N1), comme
|
||
|
|
// LPColorGradeSubsystem.cpp:295, sinon police par defaut de Slate ; puis taille 16 et contour 2 noir 0,8 de
|
||
|
|
// l'auteur (SPEC 1.1 A5). FSlateFontInfo::Size et OutlineSettings : SlateFontInfo.h:175, :160 ;
|
||
|
|
// FFontOutlineSettings(int32, FLinearColor) : SlateFontInfo.h:78.
|
||
|
|
FSlateFontInfo RewardFont(const UUserWidget* Cursor)
|
||
|
|
{
|
||
|
|
const UTextBlock* Sample = Cast<UTextBlock>(Cursor->GetWidgetFromName(FName(ActionTextName)));
|
||
|
|
FSlateFontInfo Font = Sample ? Sample->GetFont() : FCoreStyle::GetDefaultFontStyle("Regular", RewardFontSize);
|
||
|
|
Font.Size = RewardFontSize;
|
||
|
|
Font.OutlineSettings = FFontOutlineSettings(RewardOutlineSize, FLinearColor(0.f, 0.f, 0.f, 0.8f));
|
||
|
|
return Font;
|
||
|
|
}
|
||
|
|
|
||
|
|
FProperty* FindProp(const UObject* Owner, const TCHAR* Name)
|
||
|
|
{
|
||
|
|
return Owner ? Owner->GetClass()->FindPropertyByName(FName(Name)) : nullptr;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Parametre d'une fonction Blueprint, par nom (comme LPDirectControlSubsystem.cpp:375-385).
|
||
|
|
FProperty* FindParm(UFunction* Function, const TCHAR* Name)
|
||
|
|
{
|
||
|
|
for (TFieldIterator<FProperty> It(Function); It && It->HasAnyPropertyFlags(CPF_Parm); ++It)
|
||
|
|
{
|
||
|
|
if (It->GetAuthoredName() == Name || It->GetName() == Name)
|
||
|
|
{
|
||
|
|
return *It;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return nullptr;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Liste lisible des parametres, pour l'avertissement unique quand la signature n'est pas celle attendue.
|
||
|
|
FString DescribeParms(UFunction* Function)
|
||
|
|
{
|
||
|
|
FString Out;
|
||
|
|
for (TFieldIterator<FProperty> It(Function); It && It->HasAnyPropertyFlags(CPF_Parm); ++It)
|
||
|
|
{
|
||
|
|
if (!Out.IsEmpty())
|
||
|
|
{
|
||
|
|
Out += TEXT(", ");
|
||
|
|
}
|
||
|
|
Out += FString::Printf(TEXT("%s (%s%s)"), *It->GetAuthoredName(), *It->GetClass()->GetName(),
|
||
|
|
It->HasAnyPropertyFlags(CPF_OutParm) ? TEXT(", sortie") : TEXT(""));
|
||
|
|
}
|
||
|
|
return Out;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Reel Blueprint : double en 5.x (FDoubleProperty), float accepte aussi (comme LPUserSettings.cpp:32-55).
|
||
|
|
bool IsReal(const FProperty* Prop)
|
||
|
|
{
|
||
|
|
return CastField<FDoubleProperty>(Prop) || CastField<FFloatProperty>(Prop);
|
||
|
|
}
|
||
|
|
|
||
|
|
double ReadReal(const FProperty* Prop, const void* Container)
|
||
|
|
{
|
||
|
|
if (const FDoubleProperty* AsDouble = CastField<FDoubleProperty>(Prop))
|
||
|
|
{
|
||
|
|
return AsDouble->GetPropertyValue_InContainer(Container);
|
||
|
|
}
|
||
|
|
if (const FFloatProperty* AsFloat = CastField<FFloatProperty>(Prop))
|
||
|
|
{
|
||
|
|
return static_cast<double>(AsFloat->GetPropertyValue_InContainer(Container));
|
||
|
|
}
|
||
|
|
return 0.0;
|
||
|
|
}
|
||
|
|
|
||
|
|
void WriteReal(const FProperty* Prop, void* Container, double Value)
|
||
|
|
{
|
||
|
|
if (const FDoubleProperty* AsDouble = CastField<FDoubleProperty>(Prop))
|
||
|
|
{
|
||
|
|
AsDouble->SetPropertyValue_InContainer(Container, Value);
|
||
|
|
}
|
||
|
|
else if (const FFloatProperty* AsFloat = CastField<FFloatProperty>(Prop))
|
||
|
|
{
|
||
|
|
AsFloat->SetPropertyValue_InContainer(Container, static_cast<float>(Value));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
// Booleen d'entree d'une fonction : present et booleen, sinon faux (l'appelant avertit et abandonne).
|
||
|
|
bool SetBoolParm(UFunction* Function, void* Parms, const TCHAR* Name, bool bValue)
|
||
|
|
{
|
||
|
|
const FBoolProperty* Prop = CastField<FBoolProperty>(FindParm(Function, Name));
|
||
|
|
if (!Prop)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
Prop->SetPropertyValue_InContainer(Parms, bValue);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Parametres d'un appel par ProcessEvent : memoire fournie par l'appelant (FMemory_Alloca_Aligned, qui doit rester
|
||
|
|
// dans le cadre de l'appelant), mise a zero et initialisee ici, detruite a la sortie de portee
|
||
|
|
// (meme sequence que LPDirectControlSubsystem.cpp:426-455).
|
||
|
|
struct FScopedParms
|
||
|
|
{
|
||
|
|
UFunction* Function;
|
||
|
|
uint8* Memory;
|
||
|
|
|
||
|
|
FScopedParms(UFunction* InFunction, uint8* InMemory)
|
||
|
|
: Function(InFunction)
|
||
|
|
, Memory(InMemory)
|
||
|
|
{
|
||
|
|
FMemory::Memzero(Memory, Function->ParmsSize);
|
||
|
|
for (TFieldIterator<FProperty> It(Function); It && It->HasAnyPropertyFlags(CPF_Parm); ++It)
|
||
|
|
{
|
||
|
|
It->InitializeValue_InContainer(Memory);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
~FScopedParms()
|
||
|
|
{
|
||
|
|
for (TFieldIterator<FProperty> It(Function); It && It->HasAnyPropertyFlags(CPF_Parm); ++It)
|
||
|
|
{
|
||
|
|
It->DestroyValue_InContainer(Memory);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
FScopedParms(const FScopedParms&) = delete;
|
||
|
|
FScopedParms& operator=(const FScopedParms&) = delete;
|
||
|
|
};
|
||
|
|
|
||
|
|
// Proprietes lues par reflexion. Faux : propriete absente ou d'un autre type (l'appelant avertit).
|
||
|
|
bool ReadObject(const UObject* Owner, const TCHAR* Name, UObject*& Out)
|
||
|
|
{
|
||
|
|
Out = nullptr;
|
||
|
|
const FObjectPropertyBase* Prop = CastField<FObjectPropertyBase>(FindProp(Owner, Name));
|
||
|
|
if (!Prop)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
Out = Prop->GetObjectPropertyValue_InContainer(Owner);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Tableau d'objets (comme LPShowCoupleSubsystem.cpp:80-96).
|
||
|
|
bool ReadObjects(const UObject* Owner, const TCHAR* Name, TArray<UObject*>& Out)
|
||
|
|
{
|
||
|
|
Out.Reset();
|
||
|
|
const FArrayProperty* ArrayProp = CastField<FArrayProperty>(FindProp(Owner, Name));
|
||
|
|
const FObjectPropertyBase* Inner = ArrayProp ? CastField<FObjectPropertyBase>(ArrayProp->Inner) : nullptr;
|
||
|
|
if (!Inner)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
FScriptArrayHelper Helper(ArrayProp, ArrayProp->ContainerPtrToValuePtr<void>(Owner));
|
||
|
|
for (int32 Index = 0; Index < Helper.Num(); ++Index)
|
||
|
|
{
|
||
|
|
Out.Add(Inner->GetObjectPropertyValue(Helper.GetRawPtr(Index)));
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Tableau de chaines (GI.CurrentTags). D2 (STE-ORG5-V1-VAL.md) : type reel non lu, elements chaine, nom ou texte
|
||
|
|
// acceptes et convertis en chaines.
|
||
|
|
bool ReadStrings(const UObject* Owner, const TCHAR* Name, TArray<FString>& Out)
|
||
|
|
{
|
||
|
|
Out.Reset();
|
||
|
|
const FArrayProperty* ArrayProp = CastField<FArrayProperty>(FindProp(Owner, Name));
|
||
|
|
if (!ArrayProp)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
const FStrProperty* AsStr = CastField<FStrProperty>(ArrayProp->Inner);
|
||
|
|
const FNameProperty* AsName = CastField<FNameProperty>(ArrayProp->Inner);
|
||
|
|
const FTextProperty* AsText = CastField<FTextProperty>(ArrayProp->Inner);
|
||
|
|
if (!AsStr && !AsName && !AsText)
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
FScriptArrayHelper Helper(ArrayProp, ArrayProp->ContainerPtrToValuePtr<void>(Owner));
|
||
|
|
Out.Reserve(Helper.Num());
|
||
|
|
for (int32 Index = 0; Index < Helper.Num(); ++Index)
|
||
|
|
{
|
||
|
|
const void* Item = Helper.GetRawPtr(Index);
|
||
|
|
if (AsStr)
|
||
|
|
{
|
||
|
|
Out.Add(AsStr->GetPropertyValue(Item));
|
||
|
|
}
|
||
|
|
else if (AsName)
|
||
|
|
{
|
||
|
|
Out.Add(AsName->GetPropertyValue(Item).ToString());
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Out.Add(AsText->GetPropertyValue(Item).ToString());
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void ULPBonusRewardSubsystem::Initialize(FSubsystemCollectionBase& Collection)
|
||
|
|
{
|
||
|
|
Super::Initialize(Collection);
|
||
|
|
Rng.GenerateNewSeed();
|
||
|
|
|
||
|
|
FString Failure;
|
||
|
|
if (CheckFormula(Failure))
|
||
|
|
{
|
||
|
|
UE_LOG(LogLifePlay, Log, TEXT("Bonus : contrôle formule OK"));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
UE_LOG(LogLifePlay, Error, TEXT("Bonus : contrôle formule en erreur, %s"), *Failure);
|
||
|
|
}
|
||
|
|
UE_LOG(LogLifePlay, Log, TEXT("Bonus : réglage bDisabled = %s ([/Script/LifePlay.LPBonusRewardSettings], config Game)"),
|
||
|
|
GetDefault<ULPBonusRewardSettings>()->bDisabled ? TEXT("vrai") : TEXT("faux"));
|
||
|
|
|
||
|
|
TickHandle = FTSTicker::GetCoreTicker().AddTicker(
|
||
|
|
FTickerDelegate::CreateUObject(this, &ULPBonusRewardSubsystem::Tick), LPBonusReward::PollSeconds);
|
||
|
|
}
|
||
|
|
|
||
|
|
void ULPBonusRewardSubsystem::Deinitialize()
|
||
|
|
{
|
||
|
|
FTSTicker::GetCoreTicker().RemoveTicker(TickHandle);
|
||
|
|
Pending.Reset();
|
||
|
|
LastCounts.Reset();
|
||
|
|
// Garde 3 : minuteries des lignes videes ; les widgets ne sont pas touches ici (ils partent avec le monde et le
|
||
|
|
// GameInstance en cours de fermeture).
|
||
|
|
ClearRewardDisplay(false);
|
||
|
|
RewardBox.Reset();
|
||
|
|
Super::Deinitialize();
|
||
|
|
}
|
||
|
|
|
||
|
|
const TArray<FLPBonusStat>& ULPBonusRewardSubsystem::Table()
|
||
|
|
{
|
||
|
|
// STE-ORG5-SPEC.md section 1.2 (valeur par defaut de Cursor.statTags chez l'auteur), meme ordre.
|
||
|
|
static const TArray<FLPBonusStat> Stats = {
|
||
|
|
{ TEXT("perversion"), {} },
|
||
|
|
{ TEXT("masochist"), { TEXT("Aggressive"), TEXT("AggressiveFM") } },
|
||
|
|
{ TEXT("prone_to_orgasm"), {} },
|
||
|
|
{ TEXT("attractiontoplayer"), {} },
|
||
|
|
{ TEXT("fitness"), { TEXT("Penetration"), TEXT("Foreplay"), TEXT("Cum") } },
|
||
|
|
{ TEXT("likes_anal"), { TEXT("Anal") } },
|
||
|
|
{ TEXT("likes_boobjob"), { TEXT("Titfuck"), TEXT("Boobjob") } },
|
||
|
|
{ TEXT("likes_cowgirl"), { TEXT("Cow"), TEXT("Cowgirl") } },
|
||
|
|
{ TEXT("likes_doggy"), { TEXT("Doggy"), TEXT("Doggystyle") } },
|
||
|
|
{ TEXT("likes_handjob"), { TEXT("Handjob"), TEXT("RubPussy"), TEXT("FingerPussy") } },
|
||
|
|
{ TEXT("likes_missionary"), { TEXT("Missionary") } },
|
||
|
|
{ TEXT("likes_oral"), { TEXT("Oral"), TEXT("Blowjob"), TEXT("Cunnilingus"), TEXT("LickPussy"), TEXT("LickAss"), TEXT("Rimjob") } },
|
||
|
|
{ TEXT("likes_rcowgirl"), { TEXT("ReverseCow"), TEXT("ReverseCowgirl") } },
|
||
|
|
{ TEXT("likes_rough"), { TEXT("Aggressive"), TEXT("AggressiveFM") } },
|
||
|
|
{ TEXT("likes_sidefuck"), { TEXT("Spooning"), TEXT("Sidefuck"), TEXT("Spoon") } },
|
||
|
|
{ TEXT("likes_toys"), { TEXT("Toys"), TEXT("Dildo"), TEXT("Vibrator") } },
|
||
|
|
{ TEXT("likes_tribadism"), { TEXT("Tribadism"), TEXT("Scissor"), TEXT("Scissoring") } },
|
||
|
|
{ TEXT("likes_vaginal"), { TEXT("Vaginal") } },
|
||
|
|
{ TEXT("masochist-"), { TEXT("Aggressive"), TEXT("AggressiveFM") } },
|
||
|
|
{ TEXT("prone_to_orgasm-"), { TEXT("Penetration"), TEXT("Foreplay"), TEXT("Cum") } },
|
||
|
|
};
|
||
|
|
return Stats;
|
||
|
|
}
|
||
|
|
|
||
|
|
double ULPBonusRewardSubsystem::RewardChange(double X, bool bNegative)
|
||
|
|
{
|
||
|
|
// Ordre de l'auteur (SPEC 1.3) : Abs, MapRangeClamped(0, 100, 0, 1.9), 2 - m, * 10, FCeil, entier -> reel, / 10,
|
||
|
|
// * signe (SelectFloat(-1, 1, EndsWith("-"))). Memes fonctions que les noeuds Blueprint (KismetMathLibrary.h:796,
|
||
|
|
// :836), en double comme les Blueprints 5.x.
|
||
|
|
const double Mapped = UKismetMathLibrary::MapRangeClamped(FMath::Abs(X), 0.0, 100.0, 0.0, 1.9);
|
||
|
|
const int32 Tenths = UKismetMathLibrary::FCeil((2.0 - Mapped) * 10.0);
|
||
|
|
const double Value = static_cast<double>(Tenths) / 10.0;
|
||
|
|
return Value * (bNegative ? -1.0 : 1.0);
|
||
|
|
}
|
||
|
|
|
||
|
|
bool ULPBonusRewardSubsystem::CheckFormula(FString& OutFailure)
|
||
|
|
{
|
||
|
|
struct FCase
|
||
|
|
{
|
||
|
|
double X;
|
||
|
|
bool bNegative;
|
||
|
|
double Expected;
|
||
|
|
};
|
||
|
|
// SPEC 2.4 : 0, 10, 25, 50, 75, 90, 100 -> 2.0, 1.9, 1.6, 1.1, 0.6, 0.3, 0.2 ; plus le signe d'une cle en '-'.
|
||
|
|
static const FCase Cases[] = {
|
||
|
|
{ 0.0, false, 2.0 }, { 10.0, false, 1.9 }, { 25.0, false, 1.6 }, { 50.0, false, 1.1 },
|
||
|
|
{ 75.0, false, 0.6 }, { 90.0, false, 0.3 }, { 100.0, false, 0.2 }, { 50.0, true, -1.1 },
|
||
|
|
};
|
||
|
|
for (const FCase& Case : Cases)
|
||
|
|
{
|
||
|
|
const double Got = RewardChange(Case.X, Case.bNegative);
|
||
|
|
if (!FMath::IsNearlyEqual(Got, Case.Expected, 1e-9))
|
||
|
|
{
|
||
|
|
OutFailure = FString::Printf(TEXT("x=%.1f%s : %.17g au lieu de %.1f"),
|
||
|
|
Case.X, Case.bNegative ? TEXT(" (baisse)") : TEXT(""), Got, Case.Expected);
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool ULPBonusRewardSubsystem::Overlaps(const TArray<FString>& A, const TArray<FString>& B, bool bIfEmptyThenTrue)
|
||
|
|
{
|
||
|
|
// GI.Overlaps (L6f_dump_GI.txt:19622-19673) : IfEmptyThenTrue ET (A vide OU B vide) -> vrai ; sinon un element de
|
||
|
|
// A contenu dans B (Array_Contains) -> vrai ; sinon faux.
|
||
|
|
if (bIfEmptyThenTrue && (A.Num() == 0 || B.Num() == 0))
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
for (const FString& Item : A)
|
||
|
|
{
|
||
|
|
if (B.Contains(Item))
|
||
|
|
{
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
void ULPBonusRewardSubsystem::Pick(const TArray<FString>& PositionTags, FRandomStream& InRng, bool bAttractionAllowed,
|
||
|
|
TArray<FString>& OutStats, TArray<bool>& OutNegative)
|
||
|
|
{
|
||
|
|
OutStats.Reset();
|
||
|
|
OutNegative.Reset();
|
||
|
|
const TArray<FLPBonusStat>& Stats = Table();
|
||
|
|
|
||
|
|
// Map_Keys(statTags) puis Array_Shuffle : meme algorithme que KismetArrayLibrary.cpp:338-352 (ici par le flux
|
||
|
|
// InRng, graine injectable), puis Array_Resize(10).
|
||
|
|
TArray<int32> Order;
|
||
|
|
Order.Reserve(Stats.Num());
|
||
|
|
for (int32 Index = 0; Index < Stats.Num(); ++Index)
|
||
|
|
{
|
||
|
|
Order.Add(Index);
|
||
|
|
}
|
||
|
|
const int32 LastIndex = Order.Num() - 1;
|
||
|
|
for (int32 i = 0; i <= LastIndex; ++i)
|
||
|
|
{
|
||
|
|
const int32 Index = InRng.RandRange(i, LastIndex);
|
||
|
|
if (i != Index)
|
||
|
|
{
|
||
|
|
Order.Swap(i, Index);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
Order.SetNum(FMath::Min(Order.Num(), LPBonusReward::CandidateCount));
|
||
|
|
|
||
|
|
for (const int32 Index : Order)
|
||
|
|
{
|
||
|
|
const FLPBonusStat& Entry = Stats[Index];
|
||
|
|
if (!Overlaps(PositionTags, Entry.Tags, true))
|
||
|
|
{
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
if (Entry.Key == LPBonusReward::AttractionKey && !bAttractionAllowed)
|
||
|
|
{
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
const bool bNegative = Entry.Key.EndsWith(TEXT("-"));
|
||
|
|
OutStats.Add(bNegative ? Entry.Key.LeftChop(1) : Entry.Key);
|
||
|
|
OutNegative.Add(bNegative);
|
||
|
|
if (OutStats.Num() == LPBonusReward::MaxRewards)
|
||
|
|
{
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
bool ULPBonusRewardSubsystem::Tick(float DeltaTime)
|
||
|
|
{
|
||
|
|
(void)DeltaTime;
|
||
|
|
if (UGameInstance* GI = GetGameInstance())
|
||
|
|
{
|
||
|
|
Poll(GI);
|
||
|
|
}
|
||
|
|
FirePending();
|
||
|
|
ExpireRewardLines();
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
void ULPBonusRewardSubsystem::Poll(UObject* GI)
|
||
|
|
{
|
||
|
|
const FBoolProperty* SexOn = CastField<FBoolProperty>(LPBonusReward::FindProp(GI, TEXT("SexOn")));
|
||
|
|
if (!SexOn)
|
||
|
|
{
|
||
|
|
// D1 (STE-ORG5-V1-VAL.md) : message construit seulement au premier passage (Poll tourne toutes les 0,1 s).
|
||
|
|
if (FirstWarning(TEXT("GI.SexOn")))
|
||
|
|
{
|
||
|
|
UE_LOG(LogLifePlay, Warning, TEXT("Bonus : pas de propriete booleenne SexOn dans %s, aucun orgasme detecte"),
|
||
|
|
*GI->GetClass()->GetName());
|
||
|
|
}
|
||
|
|
bInScene = false;
|
||
|
|
ClearRewardDisplay(true);
|
||
|
|
LastCounts.Reset();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
bInScene = SexOn->GetPropertyValue_InContainer(GI);
|
||
|
|
if (!bInScene)
|
||
|
|
{
|
||
|
|
// Hors scene : memoire des compteurs videe. Un orgasme deja detecte (Pending) garde son tempo, comme le
|
||
|
|
// RetriggerableDelay de l'auteur qui ne depend pas de la scene. Garde 3 (ORG5-I2a) : lignes de recompense
|
||
|
|
// retirees de l'ecran et minuteries videes a la sortie de scene.
|
||
|
|
LastCounts.Reset();
|
||
|
|
ClearRewardDisplay(true);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
TArray<UObject*> Persons;
|
||
|
|
if (!LPBonusReward::ReadObjects(GI, TEXT("SexPersons"), Persons))
|
||
|
|
{
|
||
|
|
if (FirstWarning(TEXT("GI.SexPersons")))
|
||
|
|
{
|
||
|
|
UE_LOG(LogLifePlay, Warning, TEXT("Bonus : pas de tableau d'objets SexPersons dans %s, aucun orgasme detecte"),
|
||
|
|
*GI->GetClass()->GetName());
|
||
|
|
}
|
||
|
|
LastCounts.Reset();
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
TSet<TWeakObjectPtr<UObject>> Seen;
|
||
|
|
for (UObject* Person : Persons)
|
||
|
|
{
|
||
|
|
if (!IsValid(Person))
|
||
|
|
{
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
const FIntProperty* CountProp = CastField<FIntProperty>(LPBonusReward::FindProp(Person, TEXT("Sex_OrgasmCounts")));
|
||
|
|
if (!CountProp)
|
||
|
|
{
|
||
|
|
if (FirstWarning(TEXT("Person.Sex_OrgasmCounts")))
|
||
|
|
{
|
||
|
|
UE_LOG(LogLifePlay, Warning, TEXT("Bonus : pas de propriete entiere Sex_OrgasmCounts dans %s, personne ignoree"),
|
||
|
|
*Person->GetClass()->GetName());
|
||
|
|
}
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
const int32 Count = CountProp->GetPropertyValue_InContainer(Person);
|
||
|
|
const TWeakObjectPtr<UObject> Key(Person);
|
||
|
|
Seen.Add(Key);
|
||
|
|
|
||
|
|
int32* Last = LastCounts.Find(Key);
|
||
|
|
if (!Last)
|
||
|
|
{
|
||
|
|
// Premier passage (debut de scene, personne qui entre) : memorisation sans recompense.
|
||
|
|
LastCounts.Add(Key, Count);
|
||
|
|
continue;
|
||
|
|
}
|
||
|
|
if (Count > *Last)
|
||
|
|
{
|
||
|
|
TArray<FString> Tags;
|
||
|
|
if (!LPBonusReward::ReadStrings(GI, TEXT("CurrentTags"), Tags))
|
||
|
|
{
|
||
|
|
WarnOnce(TEXT("GI.CurrentTags"), FString::Printf(TEXT("pas de tableau de chaines CurrentTags dans %s, orgasme sans recompense"),
|
||
|
|
*GI->GetClass()->GetName()));
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
if (Pending.IsSet())
|
||
|
|
{
|
||
|
|
UE_LOG(LogLifePlay, Verbose, TEXT("Bonus : orgasme en attente remplace par celui de %s (tempo %.1f s)"),
|
||
|
|
*PersonName(Person), LPBonusReward::DebounceSeconds);
|
||
|
|
}
|
||
|
|
FLPBonusPending NewPending;
|
||
|
|
NewPending.Person = Person;
|
||
|
|
NewPending.Tags = MoveTemp(Tags);
|
||
|
|
NewPending.Count = Count;
|
||
|
|
NewPending.FireAt = FPlatformTime::Seconds() + LPBonusReward::DebounceSeconds;
|
||
|
|
Pending = MoveTemp(NewPending);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Hausse : nouveau compteur retenu ; baisse (remise a zero du jeu) : resynchronisation sans recompense.
|
||
|
|
*Last = Count;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Personne sortie de la scene : oubliee (si elle revient, premier passage sans recompense).
|
||
|
|
for (auto It = LastCounts.CreateIterator(); It; ++It)
|
||
|
|
{
|
||
|
|
if (!Seen.Contains(It.Key()))
|
||
|
|
{
|
||
|
|
It.RemoveCurrent();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void ULPBonusRewardSubsystem::FirePending()
|
||
|
|
{
|
||
|
|
if (!Pending.IsSet() || FPlatformTime::Seconds() < Pending->FireAt)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
const FLPBonusPending Fire = MoveTemp(Pending.GetValue());
|
||
|
|
Pending.Reset();
|
||
|
|
UObject* Person = Fire.Person.Get();
|
||
|
|
if (!IsValid(Person))
|
||
|
|
{
|
||
|
|
UE_LOG(LogLifePlay, Verbose, TEXT("Bonus : personne disparue avant la fin du tempo, pas de recompense"));
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
OnOrgasm(Person, Fire.Tags, Fire.Count);
|
||
|
|
}
|
||
|
|
|
||
|
|
void ULPBonusRewardSubsystem::OnOrgasm(UObject* Person, const TArray<FString>& TagsCapturedAtDetection, int32 Count)
|
||
|
|
{
|
||
|
|
const FString Name = PersonName(Person);
|
||
|
|
UE_LOG(LogLifePlay, Log, TEXT("Bonus : orgasme de %s (compteur %d)"), *Name, Count);
|
||
|
|
|
||
|
|
if (GetDefault<ULPBonusRewardSettings>()->bDisabled)
|
||
|
|
{
|
||
|
|
UE_LOG(LogLifePlay, Log, TEXT("Bonus : désactivé (bDisabled)"));
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
UGameInstance* GI = GetGameInstance();
|
||
|
|
const bool bAttraction = GI && AttractionAllowed(GI, Person);
|
||
|
|
TArray<FString> Stats;
|
||
|
|
TArray<bool> Negative;
|
||
|
|
Pick(TagsCapturedAtDetection, Rng, bAttraction, Stats, Negative);
|
||
|
|
if (Stats.Num() == 0)
|
||
|
|
{
|
||
|
|
UE_LOG(LogLifePlay, Log, TEXT("Bonus : aucune récompense éligible pour %s"), *Name);
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// V-min : la premiere recompense retenue est appliquee (l'auteur en propose jusqu'a 3 et le joueur choisit).
|
||
|
|
double X = 0.0;
|
||
|
|
if (!QueryStat(Person, Stats[0], X))
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
const double Change = RewardChange(X, Negative[0]);
|
||
|
|
if (!ModifyStat(Person, Stats[0], Change))
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
UE_LOG(LogLifePlay, Log, TEXT("Bonus : %s %s %+.1f (x=%.2f, tags=%d)"),
|
||
|
|
*Name, *Stats[0], Change, X, TagsCapturedAtDetection.Num());
|
||
|
|
|
||
|
|
// ORG5-I2a : ligne affichee dans le menu d'actions (EquipMenu de Cursor) ; un echec d'affichage laisse la
|
||
|
|
// recompense appliquee (garde 1). bDisabled est sorti plus haut : rien n'est affiche (Q-I2-4).
|
||
|
|
ShowAppliedReward(Name, Stats[0], Change);
|
||
|
|
}
|
||
|
|
|
||
|
|
void ULPBonusRewardSubsystem::ShowAppliedReward(const FString& Name, const FString& Stat, double Change)
|
||
|
|
{
|
||
|
|
// STE-ORG5-I2-SPEC.md option (a), section 2.2 : la ligne va dans une case ajoutee comme dernier enfant d'EquipMenu
|
||
|
|
// (emplacement de BonusRewardBox chez l'auteur, SPEC 1.1 A1 a A4) ; elle suit donc l'ouverture du menu et la
|
||
|
|
// visibilite d'EquipMenu (liee a GI.SexOn, SPEC 1.1 A7) sans code de plus. Appel depuis FirePending (ticker).
|
||
|
|
if (!bInScene)
|
||
|
|
{
|
||
|
|
// Tempo de 0,2 s fini apres la fin de la scene : pas de ligne (elle serait retiree au sondage suivant).
|
||
|
|
UE_LOG(LogLifePlay, Verbose, TEXT("Bonus : scene terminee avant l'affichage, ligne non affichee"));
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
UGameInstance* GI = GetGameInstance();
|
||
|
|
if (!GI)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
UUserWidget* Cursor = FindCursor(GI);
|
||
|
|
if (!Cursor)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
UPanelWidget* Equip = FindEquipMenu(Cursor);
|
||
|
|
if (!Equip)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
EnsureEquipMenuHeight(Equip);
|
||
|
|
UVerticalBox* Box = EnsureRewardBox(Cursor, Equip);
|
||
|
|
if (!Box)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
|
||
|
|
// Remplacement (SPEC 2.2 point 4, V6-3) : au plus MaxRewardLines lignes, la plus ancienne retiree d'abord.
|
||
|
|
while (RewardLines.Num() != 0 && RewardLines.Num() >= LPBonusReward::MaxRewardLines)
|
||
|
|
{
|
||
|
|
LPBonusReward::RemoveLine(RewardLines[0]);
|
||
|
|
RewardLines.RemoveAt(0);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Ligne creee dans l'arbre de widgets de Cursor (UWidgetTree::ConstructWidget, WidgetTree.h:106-117 :
|
||
|
|
// NewObject avec l'arbre pour outer), nom automatique.
|
||
|
|
UTextBlock* Line = Cursor->WidgetTree->ConstructWidget<UTextBlock>(UTextBlock::StaticClass());
|
||
|
|
if (!Line)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
// Meme format que la ligne de journal ci-dessus (%+.1f, SPEC Q-I2-6).
|
||
|
|
Line->SetText(FText::FromString(FString::Printf(TEXT("Bonus : %s %s %+.1f"), *Name, *Stat, Change)));
|
||
|
|
Line->SetFont(LPBonusReward::RewardFont(Cursor));
|
||
|
|
Line->SetColorAndOpacity(FSlateColor(FLinearColor::White));
|
||
|
|
if (UVerticalBoxSlot* LineSlot = Box->AddChildToVerticalBox(Line))
|
||
|
|
{
|
||
|
|
// Marges de ScrollBonuses chez l'auteur (SPEC 1.1 A4) : gauche 10, haut 5, droite 10.
|
||
|
|
LineSlot->SetPadding(FMargin(10.f, 5.f, 10.f, 0.f));
|
||
|
|
LineSlot->SetHorizontalAlignment(HAlign_Left);
|
||
|
|
}
|
||
|
|
FLPBonusRewardLine Entry;
|
||
|
|
Entry.Line = Line;
|
||
|
|
Entry.ExpireAt = FPlatformTime::Seconds() + LPBonusReward::RewardLineSeconds;
|
||
|
|
RewardLines.Add(Entry);
|
||
|
|
UE_LOG(LogLifePlay, Verbose, TEXT("Bonus : ligne affichee pour %.0f s"), LPBonusReward::RewardLineSeconds);
|
||
|
|
}
|
||
|
|
|
||
|
|
UUserWidget* ULPBonusRewardSubsystem::FindCursor(UObject* GI)
|
||
|
|
{
|
||
|
|
// Garde 1 : GI.Cursor est une propriete Blueprint, lue par reflexion comme GI.PlayerCharacter ; type reel non lu,
|
||
|
|
// verifie par Cast en UUserWidget. Introuvable : un avertissement par cause, la recompense reste appliquee.
|
||
|
|
UObject* Value = nullptr;
|
||
|
|
if (!LPBonusReward::ReadObject(GI, LPBonusReward::CursorProp, Value))
|
||
|
|
{
|
||
|
|
if (FirstWarning(TEXT("GI.Cursor")))
|
||
|
|
{
|
||
|
|
UE_LOG(LogLifePlay, Warning, TEXT("Bonus : pas de propriete objet Cursor dans %s, recompense appliquee sans affichage"),
|
||
|
|
*GI->GetClass()->GetName());
|
||
|
|
}
|
||
|
|
return nullptr;
|
||
|
|
}
|
||
|
|
UUserWidget* Cursor = Cast<UUserWidget>(Value);
|
||
|
|
if (!IsValid(Cursor) || !Cursor->WidgetTree)
|
||
|
|
{
|
||
|
|
if (FirstWarning(TEXT("GI.Cursor.Value")))
|
||
|
|
{
|
||
|
|
UE_LOG(LogLifePlay, Warning, TEXT("Bonus : GI.Cursor vide, sans arbre de widgets ou d'une classe autre que UserWidget (%s), recompense appliquee sans affichage"),
|
||
|
|
*GetNameSafe(Value ? Value->GetClass() : nullptr));
|
||
|
|
}
|
||
|
|
return nullptr;
|
||
|
|
}
|
||
|
|
return Cursor;
|
||
|
|
}
|
||
|
|
|
||
|
|
UPanelWidget* ULPBonusRewardSubsystem::FindEquipMenu(UUserWidget* Cursor)
|
||
|
|
{
|
||
|
|
// UUserWidget::GetWidgetFromName = WidgetTree->FindWidget(Name) (UserWidget.cpp:1259-1262), parcours de l'arbre
|
||
|
|
// (WidgetTree.cpp:40-54) : trouve aussi un widget qui n'est pas une variable. Type verifie par Cast (garde 1).
|
||
|
|
UWidget* Found = Cursor->GetWidgetFromName(FName(LPBonusReward::EquipMenuName));
|
||
|
|
UPanelWidget* Equip = Cast<UPanelWidget>(Found);
|
||
|
|
if (!IsValid(Equip))
|
||
|
|
{
|
||
|
|
if (FirstWarning(TEXT("Cursor.EquipMenu")))
|
||
|
|
{
|
||
|
|
UE_LOG(LogLifePlay, Warning, TEXT("Bonus : pas de panneau EquipMenu dans %s (trouve : %s), recompense appliquee sans affichage"),
|
||
|
|
*Cursor->GetClass()->GetName(), *GetNameSafe(Found ? Found->GetClass() : nullptr));
|
||
|
|
}
|
||
|
|
return nullptr;
|
||
|
|
}
|
||
|
|
return Equip;
|
||
|
|
}
|
||
|
|
|
||
|
|
void ULPBonusRewardSubsystem::EnsureEquipMenuHeight(UPanelWidget* Equip)
|
||
|
|
{
|
||
|
|
// Q-I2-3 : hauteur de l'auteur (500, SPEC 1.1 A3) si elle est inferieure (350 chez nous, SPEC 1.4 N1). EquipMenu
|
||
|
|
// est enfant du CanvasPanel BelowCursor : sa hauteur est celle de son slot (UCanvasPanelSlot::GetSize / SetSize,
|
||
|
|
// CanvasPanelSlot.h:116, :112), qui n'a ce sens que sans taille automatique (GetAutoSize, :148) et sans ancres
|
||
|
|
// etirees verticalement (GetAnchors, :132 ; FAnchors::IsStretchedVertical, Anchors.h:78). Sinon : rien change.
|
||
|
|
UPanelSlot* EquipSlot = Equip->Slot.Get();
|
||
|
|
UCanvasPanelSlot* CanvasSlot = Cast<UCanvasPanelSlot>(EquipSlot);
|
||
|
|
if (!CanvasSlot)
|
||
|
|
{
|
||
|
|
if (FirstWarning(TEXT("EquipMenu.Slot")))
|
||
|
|
{
|
||
|
|
UE_LOG(LogLifePlay, Warning, TEXT("Bonus : EquipMenu n'est pas dans un CanvasPanel (slot %s), hauteur inchangee"),
|
||
|
|
*GetNameSafe(EquipSlot ? EquipSlot->GetClass() : nullptr));
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (CanvasSlot->GetAutoSize() || CanvasSlot->GetAnchors().IsStretchedVertical())
|
||
|
|
{
|
||
|
|
if (FirstWarning(TEXT("EquipMenu.Slot.Layout")))
|
||
|
|
{
|
||
|
|
UE_LOG(LogLifePlay, Warning, TEXT("Bonus : slot d'EquipMenu en taille automatique ou etire verticalement, hauteur inchangee"));
|
||
|
|
}
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
const FVector2D Size = CanvasSlot->GetSize();
|
||
|
|
if (Size.Y < LPBonusReward::EquipMenuMinHeight)
|
||
|
|
{
|
||
|
|
CanvasSlot->SetSize(FVector2D(Size.X, LPBonusReward::EquipMenuMinHeight));
|
||
|
|
UE_LOG(LogLifePlay, Log, TEXT("Bonus : hauteur d'EquipMenu portee de %.0f a %.0f"), Size.Y, LPBonusReward::EquipMenuMinHeight);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
UVerticalBox* ULPBonusRewardSubsystem::EnsureRewardBox(UUserWidget* Cursor, UPanelWidget* Equip)
|
||
|
|
{
|
||
|
|
// Garde 2 (aucun ajout en double) : la case est retrouvee avant toute creation, dans l'ordre : pointeur faible
|
||
|
|
// encore enfant de cet EquipMenu ; enfant d'EquipMenu de ce nom ; objet de ce nom dans l'arbre de Cursor (case
|
||
|
|
// detachee, reprise au lieu d'un NewObject du meme nom). Creee seulement si aucune n'existe.
|
||
|
|
UVerticalBox* Box = RewardBox.Get();
|
||
|
|
if (IsValid(Box) && Box->GetParent() == Equip)
|
||
|
|
{
|
||
|
|
return Box;
|
||
|
|
}
|
||
|
|
|
||
|
|
Box = nullptr;
|
||
|
|
const FName BoxName(LPBonusReward::RewardBoxName);
|
||
|
|
bool bAttached = false;
|
||
|
|
for (int32 Index = 0; Index < Equip->GetChildrenCount(); ++Index)
|
||
|
|
{
|
||
|
|
UWidget* Child = Equip->GetChildAt(Index);
|
||
|
|
if (Child && Child->GetFName() == BoxName)
|
||
|
|
{
|
||
|
|
Box = Cast<UVerticalBox>(Child);
|
||
|
|
bAttached = true;
|
||
|
|
break;
|
||
|
|
}
|
||
|
|
}
|
||
|
|
UWidgetTree* Tree = Cursor->WidgetTree.Get();
|
||
|
|
if (!bAttached)
|
||
|
|
{
|
||
|
|
// FindObjectFast<T>(Outer, Name) : UObjectGlobals.h:2059 ; UObject pour voir un objet de ce nom de toute classe.
|
||
|
|
if (UObject* Existing = FindObjectFast<UObject>(Tree, BoxName))
|
||
|
|
{
|
||
|
|
Box = Cast<UVerticalBox>(Existing);
|
||
|
|
if (IsValid(Box))
|
||
|
|
{
|
||
|
|
Box->RemoveFromParent();
|
||
|
|
}
|
||
|
|
}
|
||
|
|
else
|
||
|
|
{
|
||
|
|
Box = Tree->ConstructWidget<UVerticalBox>(UVerticalBox::StaticClass(), BoxName);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
if (!IsValid(Box))
|
||
|
|
{
|
||
|
|
if (FirstWarning(TEXT("LPBonusRewardBox.Type")))
|
||
|
|
{
|
||
|
|
UE_LOG(LogLifePlay, Warning, TEXT("Bonus : un objet %s existe deja sans etre une VerticalBox utilisable, recompense appliquee sans affichage"),
|
||
|
|
LPBonusReward::RewardBoxName);
|
||
|
|
}
|
||
|
|
return nullptr;
|
||
|
|
}
|
||
|
|
if (!bAttached)
|
||
|
|
{
|
||
|
|
// UPanelWidget::AddChild (PanelWidget.h:59) ajoute en dernier : meme indice que BonusRewardBox chez l'auteur.
|
||
|
|
UPanelSlot* BoxSlot = Equip->AddChild(Box);
|
||
|
|
if (!BoxSlot)
|
||
|
|
{
|
||
|
|
if (FirstWarning(TEXT("EquipMenu.AddChild")))
|
||
|
|
{
|
||
|
|
UE_LOG(LogLifePlay, Warning, TEXT("Bonus : EquipMenu (%s) refuse un enfant de plus, recompense appliquee sans affichage"),
|
||
|
|
*Equip->GetClass()->GetName());
|
||
|
|
}
|
||
|
|
return nullptr;
|
||
|
|
}
|
||
|
|
// Slot Fill comme BonusRewardBox chez l'auteur (SPEC 1.1 A4) ; autre panneau que VerticalBox : slot laisse tel quel.
|
||
|
|
if (UVerticalBoxSlot* VerticalSlot = Cast<UVerticalBoxSlot>(BoxSlot))
|
||
|
|
{
|
||
|
|
VerticalSlot->SetSize(FSlateChildSize(ESlateSizeRule::Fill));
|
||
|
|
}
|
||
|
|
}
|
||
|
|
// Case retrouvee ou reprise : ses anciennes lignes ne sont plus suivies, elles sont retirees ici.
|
||
|
|
Box->ClearChildren();
|
||
|
|
RewardLines.Reset();
|
||
|
|
RewardBox = Box;
|
||
|
|
if (!bDisplayTargetLogged)
|
||
|
|
{
|
||
|
|
bDisplayTargetLogged = true;
|
||
|
|
UE_LOG(LogLifePlay, Log, TEXT("Bonus : affichage dans EquipMenu (classe %s, %d enfants)"),
|
||
|
|
*Equip->GetClass()->GetName(), Equip->GetChildrenCount());
|
||
|
|
}
|
||
|
|
return Box;
|
||
|
|
}
|
||
|
|
|
||
|
|
void ULPBonusRewardSubsystem::ExpireRewardLines()
|
||
|
|
{
|
||
|
|
// Q-I2-2 : chaque ligne est retiree 20 s apres son affichage. Echeance en temps reel (FPlatformTime::Seconds, meme
|
||
|
|
// horloge que le tempo de 0,2 s), relue a chaque passage du ticker existant (0,1 s) : retrait entre 20,0 et 20,1 s.
|
||
|
|
if (RewardLines.Num() == 0)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
const double Now = FPlatformTime::Seconds();
|
||
|
|
for (int32 Index = RewardLines.Num() - 1; Index >= 0; --Index)
|
||
|
|
{
|
||
|
|
if (Now >= RewardLines[Index].ExpireAt || !RewardLines[Index].Line.IsValid())
|
||
|
|
{
|
||
|
|
LPBonusReward::RemoveLine(RewardLines[Index]);
|
||
|
|
RewardLines.RemoveAt(Index);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
void ULPBonusRewardSubsystem::ClearRewardDisplay(bool bRemoveWidgets)
|
||
|
|
{
|
||
|
|
// Garde 3 : fin de scene (Poll, SexOn faux) : lignes retirees de l'ecran et minuteries videes ; Deinitialize :
|
||
|
|
// minuteries videes seulement.
|
||
|
|
if (RewardLines.Num() == 0)
|
||
|
|
{
|
||
|
|
return;
|
||
|
|
}
|
||
|
|
if (bRemoveWidgets)
|
||
|
|
{
|
||
|
|
for (const FLPBonusRewardLine& Entry : RewardLines)
|
||
|
|
{
|
||
|
|
LPBonusReward::RemoveLine(Entry);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
RewardLines.Reset();
|
||
|
|
}
|
||
|
|
|
||
|
|
bool ULPBonusRewardSubsystem::AttractionAllowed(UObject* GI, UObject* Person)
|
||
|
|
{
|
||
|
|
// Condition de l'auteur (SPEC 1.1 E6c) : NON Person.isPlayer ET GI.IsInterestedIn(Person, GI.PlayerCharacter) ET
|
||
|
|
// GI.SexPersons contient GI.PlayerCharacter. Propriete ou fonction absente : avertissement, cle refusee.
|
||
|
|
const FBoolProperty* IsPlayerProp = CastField<FBoolProperty>(LPBonusReward::FindProp(Person, TEXT("isPlayer")));
|
||
|
|
if (!IsPlayerProp)
|
||
|
|
{
|
||
|
|
WarnOnce(TEXT("Person.isPlayer"), FString::Printf(TEXT("pas de propriete booleenne isPlayer dans %s, cle attractiontoplayer refusee"),
|
||
|
|
*Person->GetClass()->GetName()));
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (IsPlayerProp->GetPropertyValue_InContainer(Person))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
UObject* Player = nullptr;
|
||
|
|
if (!LPBonusReward::ReadObject(GI, TEXT("PlayerCharacter"), Player))
|
||
|
|
{
|
||
|
|
WarnOnce(TEXT("GI.PlayerCharacter"), FString::Printf(TEXT("pas de propriete objet PlayerCharacter dans %s, cle attractiontoplayer refusee"),
|
||
|
|
*GI->GetClass()->GetName()));
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (!IsValid(Player))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
TArray<UObject*> Persons;
|
||
|
|
if (!LPBonusReward::ReadObjects(GI, TEXT("SexPersons"), Persons) || !Persons.Contains(Player))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
bool bInterested = false;
|
||
|
|
if (!IsInterestedIn(GI, Person, Player, bInterested))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
return bInterested;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool ULPBonusRewardSubsystem::IsInterestedIn(UObject* GI, UObject* WhoIsInterested, UObject* WhoInterests, bool& bOutInterested)
|
||
|
|
{
|
||
|
|
// GI.IsInterestedIn(WhoIsInterested, WhoInterests) -> Interested (L6f_dump_GI.txt:23421-23424, :23442-23443).
|
||
|
|
bOutInterested = false;
|
||
|
|
UFunction* Function = GI->FindFunction(FName(TEXT("IsInterestedIn")));
|
||
|
|
if (!Function)
|
||
|
|
{
|
||
|
|
WarnOnce(TEXT("GI.IsInterestedIn"), FString::Printf(TEXT("fonction IsInterestedIn introuvable dans %s, cle attractiontoplayer refusee"),
|
||
|
|
*GI->GetClass()->GetName()));
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
const FObjectPropertyBase* WhoIsParm = CastField<FObjectPropertyBase>(LPBonusReward::FindParm(Function, TEXT("WhoIsInterested")));
|
||
|
|
const FObjectPropertyBase* WhoParm = CastField<FObjectPropertyBase>(LPBonusReward::FindParm(Function, TEXT("WhoInterests")));
|
||
|
|
const FBoolProperty* ResultParm = CastField<FBoolProperty>(LPBonusReward::FindParm(Function, TEXT("Interested")));
|
||
|
|
if (!WhoIsParm || !WhoParm || !ResultParm || !ResultParm->HasAnyPropertyFlags(CPF_OutParm)
|
||
|
|
|| !WhoIsParm->PropertyClass || !WhoParm->PropertyClass)
|
||
|
|
{
|
||
|
|
WarnOnce(TEXT("GI.IsInterestedIn.Parms"), FString::Printf(TEXT("signature inattendue de IsInterestedIn : %s ; cle attractiontoplayer refusee"),
|
||
|
|
*LPBonusReward::DescribeParms(Function)));
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
if (!WhoIsInterested->IsA(WhoIsParm->PropertyClass) || !WhoInterests->IsA(WhoParm->PropertyClass))
|
||
|
|
{
|
||
|
|
WarnOnce(TEXT("GI.IsInterestedIn.Types"), FString::Printf(TEXT("IsInterestedIn attend %s et %s, recu %s et %s ; cle attractiontoplayer refusee"),
|
||
|
|
*WhoIsParm->PropertyClass->GetName(), *WhoParm->PropertyClass->GetName(),
|
||
|
|
*WhoIsInterested->GetClass()->GetName(), *WhoInterests->GetClass()->GetName()));
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
const int32 ParmsSize = Function->ParmsSize;
|
||
|
|
const int32 Alignment = Function->GetMinAlignment();
|
||
|
|
uint8* Memory = static_cast<uint8*>(FMemory_Alloca_Aligned(ParmsSize, Alignment));
|
||
|
|
LPBonusReward::FScopedParms Parms(Function, Memory);
|
||
|
|
WhoIsParm->SetObjectPropertyValue_InContainer(Memory, WhoIsInterested);
|
||
|
|
WhoParm->SetObjectPropertyValue_InContainer(Memory, WhoInterests);
|
||
|
|
GI->ProcessEvent(Function, Memory);
|
||
|
|
bOutInterested = ResultParm->GetPropertyValue_InContainer(Memory);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool ULPBonusRewardSubsystem::QueryStat(UObject* Person, const FString& Stat, double& OutValue)
|
||
|
|
{
|
||
|
|
// Person.QueryStat(Stat, WithoutBuff, RNG) -> Value, Bonus (L6f_dump_Person.txt:20-29) ; appel de l'auteur :
|
||
|
|
// QueryStat(Stat, false, false).Value (SPEC 1.1 E6d).
|
||
|
|
OutValue = 0.0;
|
||
|
|
UFunction* Function = Person->FindFunction(FName(TEXT("QueryStat")));
|
||
|
|
if (!Function)
|
||
|
|
{
|
||
|
|
WarnOnce(TEXT("Person.QueryStat"), FString::Printf(TEXT("fonction QueryStat introuvable dans %s, recompense abandonnee"),
|
||
|
|
*Person->GetClass()->GetName()));
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
const FStrProperty* StatParm = CastField<FStrProperty>(LPBonusReward::FindParm(Function, TEXT("Stat")));
|
||
|
|
const FProperty* ValueParm = LPBonusReward::FindParm(Function, TEXT("Value"));
|
||
|
|
const bool bSignature = StatParm && LPBonusReward::IsReal(ValueParm) && ValueParm->HasAnyPropertyFlags(CPF_OutParm)
|
||
|
|
&& CastField<FBoolProperty>(LPBonusReward::FindParm(Function, TEXT("WithoutBuff")))
|
||
|
|
&& CastField<FBoolProperty>(LPBonusReward::FindParm(Function, TEXT("RNG")));
|
||
|
|
if (!bSignature)
|
||
|
|
{
|
||
|
|
WarnOnce(TEXT("Person.QueryStat.Parms"), FString::Printf(TEXT("signature inattendue de QueryStat : %s ; recompense abandonnee"),
|
||
|
|
*LPBonusReward::DescribeParms(Function)));
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
const int32 ParmsSize = Function->ParmsSize;
|
||
|
|
const int32 Alignment = Function->GetMinAlignment();
|
||
|
|
uint8* Memory = static_cast<uint8*>(FMemory_Alloca_Aligned(ParmsSize, Alignment));
|
||
|
|
LPBonusReward::FScopedParms Parms(Function, Memory);
|
||
|
|
StatParm->SetPropertyValue_InContainer(Memory, Stat);
|
||
|
|
LPBonusReward::SetBoolParm(Function, Memory, TEXT("WithoutBuff"), false);
|
||
|
|
LPBonusReward::SetBoolParm(Function, Memory, TEXT("RNG"), false);
|
||
|
|
Person->ProcessEvent(Function, Memory);
|
||
|
|
OutValue = LPBonusReward::ReadReal(ValueParm, Memory);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool ULPBonusRewardSubsystem::ModifyStat(UObject* Person, const FString& Stat, double Change)
|
||
|
|
{
|
||
|
|
// Person.ModifyStat(Stat, Change, DifficultyAdjusted, NoDisplay) -> Value (L6f_dump_Person.txt:561-570) ; appel de
|
||
|
|
// l'auteur au clic : ModifyStat(Stat, Change, false, false) (SPEC 1.1 E7).
|
||
|
|
UFunction* Function = Person->FindFunction(FName(TEXT("ModifyStat")));
|
||
|
|
if (!Function)
|
||
|
|
{
|
||
|
|
WarnOnce(TEXT("Person.ModifyStat"), FString::Printf(TEXT("fonction ModifyStat introuvable dans %s, recompense abandonnee"),
|
||
|
|
*Person->GetClass()->GetName()));
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
const FStrProperty* StatParm = CastField<FStrProperty>(LPBonusReward::FindParm(Function, TEXT("Stat")));
|
||
|
|
const FProperty* ChangeParm = LPBonusReward::FindParm(Function, TEXT("Change"));
|
||
|
|
const bool bSignature = StatParm && LPBonusReward::IsReal(ChangeParm) && !ChangeParm->HasAnyPropertyFlags(CPF_OutParm)
|
||
|
|
&& CastField<FBoolProperty>(LPBonusReward::FindParm(Function, TEXT("DifficultyAdjusted")))
|
||
|
|
&& CastField<FBoolProperty>(LPBonusReward::FindParm(Function, TEXT("NoDisplay")));
|
||
|
|
if (!bSignature)
|
||
|
|
{
|
||
|
|
WarnOnce(TEXT("Person.ModifyStat.Parms"), FString::Printf(TEXT("signature inattendue de ModifyStat : %s ; recompense abandonnee"),
|
||
|
|
*LPBonusReward::DescribeParms(Function)));
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
|
||
|
|
const int32 ParmsSize = Function->ParmsSize;
|
||
|
|
const int32 Alignment = Function->GetMinAlignment();
|
||
|
|
uint8* Memory = static_cast<uint8*>(FMemory_Alloca_Aligned(ParmsSize, Alignment));
|
||
|
|
LPBonusReward::FScopedParms Parms(Function, Memory);
|
||
|
|
StatParm->SetPropertyValue_InContainer(Memory, Stat);
|
||
|
|
LPBonusReward::WriteReal(ChangeParm, Memory, Change);
|
||
|
|
LPBonusReward::SetBoolParm(Function, Memory, TEXT("DifficultyAdjusted"), false);
|
||
|
|
LPBonusReward::SetBoolParm(Function, Memory, TEXT("NoDisplay"), false);
|
||
|
|
Person->ProcessEvent(Function, Memory);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
FString ULPBonusRewardSubsystem::PersonName(const UObject* Person)
|
||
|
|
{
|
||
|
|
// Name_First : texte chez l'auteur (SPEC 2.4) ; type non lu chez nous, texte et chaine acceptes.
|
||
|
|
const FProperty* Prop = LPBonusReward::FindProp(Person, TEXT("Name_First"));
|
||
|
|
FString Name;
|
||
|
|
if (const FTextProperty* AsText = CastField<FTextProperty>(Prop))
|
||
|
|
{
|
||
|
|
Name = AsText->GetPropertyValue_InContainer(Person).ToString();
|
||
|
|
}
|
||
|
|
else if (const FStrProperty* AsString = CastField<FStrProperty>(Prop))
|
||
|
|
{
|
||
|
|
Name = AsString->GetPropertyValue_InContainer(Person);
|
||
|
|
}
|
||
|
|
else if (Person)
|
||
|
|
{
|
||
|
|
WarnOnce(TEXT("Person.Name_First"), FString::Printf(TEXT("pas de propriete texte ou chaine Name_First dans %s, nom d'objet journalise a la place"),
|
||
|
|
*Person->GetClass()->GetName()));
|
||
|
|
}
|
||
|
|
return Name.IsEmpty() ? GetNameSafe(Person) : Name;
|
||
|
|
}
|
||
|
|
|
||
|
|
bool ULPBonusRewardSubsystem::FirstWarning(const FString& Key)
|
||
|
|
{
|
||
|
|
// D1 (STE-ORG5-V1-VAL.md) : la cause est testee avant que l'appelant construise son message.
|
||
|
|
if (Warned.Contains(Key))
|
||
|
|
{
|
||
|
|
return false;
|
||
|
|
}
|
||
|
|
Warned.Add(Key);
|
||
|
|
return true;
|
||
|
|
}
|
||
|
|
|
||
|
|
void ULPBonusRewardSubsystem::WarnOnce(const FString& Key, const FString& Message)
|
||
|
|
{
|
||
|
|
if (FirstWarning(Key))
|
||
|
|
{
|
||
|
|
UE_LOG(LogLifePlay, Warning, TEXT("Bonus : %s"), *Message);
|
||
|
|
}
|
||
|
|
}
|