Weird fatal error

Hi guys!
For some time I couldn’t compile from the Engine due to a weird error, so I did it with Visual Studio. Everything worked perfectly. Unfortunately, due to using a new plugin now I have to compile from the Engine.

Here’s the log:

LoginId:0a5c65e24eb6ac1667702e833640161b
EpicAccountId:b2819852daf645d3a9680902e9b59605

Fatal error: [File:D:/Build/++UE4/Sync/Engine/Source/Runtime/CoreUObject/Private/UObject/Obj.cpp] [Line: 112] No object initializer found during construction.

UE4Editor_CoreUObject
UE4Editor_LoTE_3418!InternalVTableHelperCtorCaller() [D:\TheEngine\UE_4.26\Engine\Source\Runtime\CoreUObject\Public\UObject\Class.h:3317]
UE4Editor_CoreUObject
UE4Editor_CoreUObject
UE4Editor_LoTE_3418!ALoTECharacter::StaticClass() [D:\Users\Lenovo\Documents\Unreal Projects\LoTE\Source\LoTE\LoTECharacter.h:26]
UE4Editor_LoTE_3418!TClassCompiledInDefer::Register() [D:\TheEngine\UE_4.26\Engine\Source\Runtime\CoreUObject\Public\UObject\UObjectBase.h:301]
UE4Editor_CoreUObject
UE4Editor_CoreUObject
UE4Editor_CoreUObject
UE4Editor_Core
UE4Editor_Core
UE4Editor_Core
UE4Editor_HotReload
UE4Editor_HotReload
UE4Editor_HotReload
UE4Editor_HotReload
UE4Editor_Core
UE4Editor
UE4Editor
UE4Editor
UE4Editor
UE4Editor
kernel32
ntdll

Here’s my character class code. Sorry for the quality, that’s one of my oldest projects and it’s yet to be refactored.

// Copyright Epic Games, Inc. All Rights Reserved.

#pragma once

#include "CoreMinimal.h"
#include "GameFramework/Character.h"
#include "InitiativeComponent.h"
#include "LoTEHUD.h"
#include "LoTECharacter.generated.h"

UENUM(BlueprintType)
enum class WType : uint8 {
	SHORT			UMETA(DisplayName = "Short"),
	ONEHANDED		UMETA(DisplayName = "OneHanded"),
	THROWING		UMETA(DisplayName = "Throwing"),
	TWOHANDED		UMETA(DisplayName = "TwoHanded"),
	POLEARM			UMETA(DisplayName = "Polearm"),
	SHOOTING		UMETA(DisplayName = "Shooting"),
	BRAWLING		UMETA(DisplayName = "Brawling"),

};

UCLASS(Blueprintable)
class ALoTECharacter : public ACharacter
{
	GENERATED_BODY()

public:
	ALoTECharacter();


	// Called every frame.
	virtual void Tick(float DeltaSeconds) override;

	/** Returns TopDownCameraComponent subobject **/
	FORCEINLINE class UCameraComponent* GetTopDownCameraComponent() const { return TopDownCameraComponent; }
	/** Returns CameraBoom subobject **/
	FORCEINLINE class USpringArmComponent* GetCameraBoom() const { return CameraBoom; }
	/** Returns CursorToWorld subobject **/
	FORCEINLINE class UDecalComponent* GetCursorToWorld() { return CursorToWorld; }

	
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	ACharacter* Enemy;
	UInitiativeComponent* CharInitiative=CreateDefaultSubobject<UInitiativeComponent>(TEXT("Initiative Component"));
	FString characterName;
	TArray<int>CStats;
	int PD;
	int strength;
	int dexterity;
	int speed;
	int endurance;
	int smarts;
	int psyche;
	int senses;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		bool isTripped;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		bool isGrabbed;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		bool isExhausted;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		bool isStunned;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		bool isFrightened;

	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetStats(int nStrength, int nDexterity, int nSpeed, int nEndurance, int nSmarts, int nPsyche, int nSenses);

	int move;
	int actionPoints;
	int healthPoints;
	int resistance;
	int talentsLimit;
	int sanity;
	int mana;
	int fortuneCards;
	int wpolearm;
	int w2handed;
	int w1handed;
	int wlight;
	int wthrowing;
	int wshooting;
	int dodging;
	int brawling;
	int antimagic;
	int whiteMagic;
	int illusions;
	int kriomancy;
	int necromancy;
	int piromancy;
	int telekinesis;
	int transmutation;
	int divination;
	int survival;
	int traps;
	int tracking;
	//int hunterOther;
	int acrobatics;
	int riding;
	int healing;
	int navigation;
	int swimming;
	int investigation;
	int perception;
	int climbing;
	int boating;
	int bluff;
	int leadership;
	int etiquette;
	int persuasion;
	int performance;
	int intimidation;
	int forgery;
	int thievery;
	int lockpicking;
	int disguise;
	//int poisoning;
	int stealth;
	int history;
	int engineering;
	int linguistics;
	int magic;
	int occultism;
	int law;
	int nature;
	int tactics;
	int enchanting;
	int alchemy;
	int artistic;
	int cooking;
	int smithing;
	int tailoring;
	int trading;
	int furriery;
	int professionalOther;

	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetSkills(int nwpolearm, int nw2handed,
			int nw1handed,
			int nwlight,
			int nwthrowing,
			int nwshooting,
			int ndodging,
			int nbrawling,
			int nantimagic,
			int nwhiteMagic,
			int nillusions,
			int nkriomancy,
			int nnecromancy,
			int npiromancy,
			int ntelekinesis,
			int ntransmutation,
			int ndivination,
			int nsurvival,
			int ntraps,
			int ntracking,
			int nacrobatics,
			int nriding,
			int nhealing,
			int nnavigation,
			int nswimming,
			int ninvestigation,
			int nperception,
			int nclimbing,
			int nboating,
			int nbluff,
			int nleadership,
			int netiquette,
			int npersuasion,
			int nperformance,
			int nintimidation,
			int nforgery,
			int nthievery,
			int nlockpicking,
			int ndisguise,
			int nstealth,
			int nhistory,
			int nengineering,
			int nlinguistics,
			int nmagic,
			int noccultism,
			int nlaw,
			int nnature,
			int ntactics,
			int nenchanting,
			int nalchemy,
			int nartistic,
			int ncooking,
			int nsmithing,
			int ntailoring,
			int ntrading,
			int nfurriery);

	int gold;
	int dmgNegation;

	int currentHP;
	int currentMove;
	int currentActionPoints;
	int currentSanity;
	int currentMana;
	int currentFortuneCards;


	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	int minWeaponDmg;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
	int maxWeaponDmg;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		int attackBonus;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		int tempAttackBonus;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		int damageBonus;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		int tempDamageBonus;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		int damageRolled;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		int attackRolled;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		int currentMoveBonus;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		int maxMoveBonus;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		int currentDefenseBonus;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		int maxDefenseBonus;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		int currentRollBonus;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		int maxRollBonus;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		WType WUsed;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		int dmgRolled;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		int attRolled;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		int currentActions;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		int maxActions;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		bool attackUsed;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		bool catchUsed;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		bool tripUsed;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		bool pushUsed;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		bool disarmUsed;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		bool aimUsed;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		bool spellcastingUsed;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		bool moveUsed;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		bool runUsed;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		int maxPurchasableActions;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		int currentPurchasableActions;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		UAnimSequenceBase* AttackAnimation;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		UAnimSequenceBase* GetHitAnimation;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		UAnimSequenceBase* CombatIdleAnimation;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		UAnimSequenceBase* DodgeAnimation;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		UAnimSequenceBase* DeathAnimation;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		UAnimSequenceBase* CatchAnimation;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		UAnimSequenceBase* TripAnimation;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		UAnimSequenceBase* BullrushAnimation;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		UAnimSequenceBase* KnockeddownAnimation;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		UAnimSequenceBase* CurrentAttackAnimation;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		UAnimSequenceBase* LyingAnimation;
	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		UAnimSequenceBase* PushedAnimation;

	UPROPERTY(EditAnywhere, BlueprintReadWrite)
		float attackRange;
	//UPROPERTY(EditAnywhere, BlueprintReadWrite)
		//int initiative;
	//UPROPERTY(EditAnywhere, BlueprintReadWrite)
		//int initiativeBonus;
	//UPROPERTY(EditAnywhere, BlueprintReadWrite)
	//	bool roundAvailable;


	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void InitializeStats(TArray<FString>Stats);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		static FString statIntToString(int stat);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetMaxHP();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetCurrentHP();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetCurrentMove();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetCurrentActionPoints();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetCurrentSanity();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetCurrentMana();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetCurrentFortuneCards();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetMaxMove();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetMaxActionPoints();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetMaxSanity();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetMaxMana();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetMaxFortuneCards();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void RefreshStats();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetPD();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetStrength();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetDexterity();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetSpeed();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetEndurance();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetSmarts();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetPsyche();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetSenses();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetGold();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetResistance();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetDmgNegation();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetTalentsLimit();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetWPolearm();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetW2Handed();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetW1Handed();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetWLight();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetWThrowing();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetWShooting();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetDodging();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetBrawling();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetAntimagic();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetWhiteMagic();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetIllusions();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetKriomancy();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetNecromancy();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetPiromancy();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetTelekinesis();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetTransmutation();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetDivination();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetSurvival();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetTraps();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetTracking();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetRiding();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetHealing();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetNavigation();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetSwimming();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetInvestigation();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetPerception();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetClimbing();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetBoating();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetBluff();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetLeadership();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetEtiquette();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetPersuasion();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetPerformance();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetIntimidation();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetForgery();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetThievery();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetLockpicking();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetDisguise();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetStealth();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetHistory();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetEngineering();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetLinguistics();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetMagic();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetOccultism();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetLaw();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetNature();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetTactics();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetEnchanting();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetAlchemy();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetArtistic();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetCooking();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetSmithing();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetTailoring();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetTrading();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetFurriery();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetProfessionalOther();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		FString GetCharacterName();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetMaxHP(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetCurrentHP(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetCurrentMove(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetCurrentActionPoints(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetCurrentSanity(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetCurrentMana(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetCurrentFortuneCards(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetMaxMove(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetMaxActionPoints(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetMaxSanity(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetMaxMana(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetMaxFortuneCards(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetPD(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetStrength(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetDexterity(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetSpeed(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetEndurance(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetSmarts(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetPsyche(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetSenses(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetGold(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetResistance(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetDmgNegation(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetTalentsLimit(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetWPolearm(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetW2Handed(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetW1Handed(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetWLight(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetWThrowing(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetWShooting(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetDodging(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetBrawling(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetAntimagic(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetWhiteMagic(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetIllusions(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetKriomancy(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetNecromancy(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetPiromancy(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetTelekinesis(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetTransmutation(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetDivination(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetSurvival(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetTraps(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetTracking(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetRiding(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetHealing(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetNavigation(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetSwimming(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetInvestigation(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetPerception(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetClimbing(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetBoating(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetBluff(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetLeadership(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetEtiquette(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetPersuasion(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetPerformance(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetIntimidation(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetForgery(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetThievery(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetLockpicking(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetDisguise(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetStealth(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetHistory(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetEngineering(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetLinguistics(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetMagic(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetOccultism(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetLaw(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetNature(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetTactics(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetEnchanting(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetAlchemy(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetArtistic(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetCooking(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetSmithing(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetTailoring(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetTrading(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetFurriery(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetProfessionalOther(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int GetAcrobatics();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetAcrobatics(int tmp);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void ReloadStats(TArray<UTextBlock*>Textblocks);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void StatsIntoArrayAlphabetically();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollSkill(int skillLevel, int statLevel);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollStat(int statLevel);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int Roll(int minNumber, int maxNumber);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollWPolearm();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollW2Handed();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollW1Handed();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollWLight();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollWThrowing();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollWShooting();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollDodging();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollBrawling();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollAntimagic();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollWhiteMagic();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollIllusions();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollKriomancy();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollNecromancy();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollPiromancy();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollTelekinesis();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollTransmutation();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollDivination();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollSurvival();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollTraps();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollTracking();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollRiding();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollHealing();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollNavigation();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollSwimming();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollInvestigation();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollPerception();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollClimbing();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollBoating();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollBluff();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollLeadership();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollEtiquette();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollPersuasion();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollPerformance();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollIntimidation();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollForgery();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollThievery();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollLockpicking();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollDisguise();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollStealth();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollHistory();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollEngineering();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollLinguistics();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollMagic();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollOccultism();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollLaw();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollNature();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollTactics();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollEnchanting();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollAlchemy();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollArtistic();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollCooking();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollSmithing();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollTailoring();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollTrading();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollFurriery();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollProfessionalOther();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollAcrobatics();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int Attack();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollStrength();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollDexterity();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollSpeed();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollEndurance();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollSmarts();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollPsyche();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollSenses();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		void SetCharacterName(FString name);
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollDamage();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		int RollParry();
	UFUNCTION(BlueprintCallable, Category = "LoTECollection")
		bool CheckIfDead();
	UFUNCTION(BlueprintCallable, BlueprintNativeEvent, Category = "LoTENative")
		void DoYourTurn();
		void DoYourTurn_Implementation();


private:
	/** Top down camera */
	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))
	class UCameraComponent* TopDownCameraComponent;

	/** Camera boom positioning the camera above the character */
	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))
	class USpringArmComponent* CameraBoom;

	/** A decal that projects to the cursor location. */
	UPROPERTY(VisibleAnywhere, BlueprintReadOnly, Category = Camera, meta = (AllowPrivateAccess = "true"))
	class UDecalComponent* CursorToWorld;
};


Here’s the .cpp

// Copyright Epic Games, Inc. All Rights Reserved.

#include "LoTECharacter.h"
#include "UObject/ConstructorHelpers.h"
#include "Camera/CameraComponent.h"
#include "Components/DecalComponent.h"
#include "Components/CapsuleComponent.h"
#include "GameFramework/CharacterMovementComponent.h"
#include "GameFramework/PlayerController.h"
#include "GameFramework/SpringArmComponent.h"
#include "HeadMountedDisplayFunctionLibrary.h"
#include "Materials/Material.h"
#include "Engine/World.h"

ALoTECharacter::ALoTECharacter()
{
	// Set size for player capsule
	GetCapsuleComponent()->InitCapsuleSize(42.f, 96.0f);

	// Don't rotate character to camera direction
	bUseControllerRotationPitch = false;
	bUseControllerRotationYaw = false;
	bUseControllerRotationRoll = false;

	// Configure character movement
	GetCharacterMovement()->bOrientRotationToMovement = true; // Rotate character to moving direction
	GetCharacterMovement()->RotationRate = FRotator(0.f, 640.f, 0.f);
	GetCharacterMovement()->bConstrainToPlane = true;
	GetCharacterMovement()->bSnapToPlaneAtStart = true;

	// Create a camera boom...
	CameraBoom = CreateDefaultSubobject<USpringArmComponent>(TEXT("CameraBoom"));
	CameraBoom->SetupAttachment(RootComponent);
	CameraBoom->SetUsingAbsoluteRotation(true); // Don't want arm to rotate when character does
	CameraBoom->TargetArmLength = 800.f;
	CameraBoom->SetRelativeRotation(FRotator(-60.f, 0.f, 0.f));
	CameraBoom->bDoCollisionTest = false; // Don't want to pull camera in when it collides with level

	// Create a camera...
	TopDownCameraComponent = CreateDefaultSubobject<UCameraComponent>(TEXT("TopDownCamera"));
	TopDownCameraComponent->SetupAttachment(CameraBoom, USpringArmComponent::SocketName);
	TopDownCameraComponent->bUsePawnControlRotation = false; // Camera does not rotate relative to arm

	// Create a decal in the world to show the cursor's location
	CursorToWorld = CreateDefaultSubobject<UDecalComponent>("CursorToWorld");
	CursorToWorld->SetupAttachment(RootComponent);
	static ConstructorHelpers::FObjectFinder<UMaterial> DecalMaterialAsset(TEXT("Material'/Game/TopDownCPP/Blueprints/M_Cursor_Decal.M_Cursor_Decal'"));
	if (DecalMaterialAsset.Succeeded())
	{
		CursorToWorld->SetDecalMaterial(DecalMaterialAsset.Object);
	}
	CursorToWorld->DecalSize = FVector(16.0f, 32.0f, 32.0f);
	CursorToWorld->SetRelativeRotation(FRotator(90.0f, 0.0f, 0.0f).Quaternion());

	// Activate ticking in order to update the cursor every frame.
	PrimaryActorTick.bCanEverTick = true;
	PrimaryActorTick.bStartWithTickEnabled = true;
}

void ALoTECharacter::Tick(float DeltaSeconds)
{
    Super::Tick(DeltaSeconds);

	if (CursorToWorld != nullptr)
	{
		if (UHeadMountedDisplayFunctionLibrary::IsHeadMountedDisplayEnabled())
		{
			if (UWorld* World = GetWorld())
			{
				FHitResult HitResult;
				FCollisionQueryParams Params(NAME_None, FCollisionQueryParams::GetUnknownStatId());
				FVector StartLocation = TopDownCameraComponent->GetComponentLocation();
				FVector EndLocation = TopDownCameraComponent->GetComponentRotation().Vector() * 2000.0f;
				Params.AddIgnoredActor(this);
				World->LineTraceSingleByChannel(HitResult, StartLocation, EndLocation, ECC_Visibility, Params);
				FQuat SurfaceRotation = HitResult.ImpactNormal.ToOrientationRotator().Quaternion();
				CursorToWorld->SetWorldLocationAndRotation(HitResult.Location, SurfaceRotation);
			}
		}
		else if (APlayerController* PC = Cast<APlayerController>(GetController()))
		{
			FHitResult TraceHitResult;
			PC->GetHitResultUnderCursor(ECC_Visibility, true, TraceHitResult);
			FVector CursorFV = TraceHitResult.ImpactNormal;
			FRotator CursorR = CursorFV.Rotation();
			CursorToWorld->SetWorldLocation(TraceHitResult.Location);
			CursorToWorld->SetWorldRotation(CursorR);
		}
	}
}

void ALoTECharacter::SetStats(int nStrength, int nDexterity, int nSpeed, int nEndurance, int nSmarts, int nPsyche, int nSenses)
{
	strength = nStrength;
	dexterity = nDexterity;
	speed = nSpeed;
	endurance = nEndurance;
	smarts = nSmarts;
	psyche = nPsyche;
	senses = nSenses;

	move = 3 + speed;
	actionPoints = 3 + speed;
	healthPoints = 3 + 5 * endurance;
	resistance = endurance / 2;
	talentsLimit = 70 * smarts;
	sanity = 3 + 5 * psyche;
	mana = 2 * psyche;
	fortuneCards = (senses + smarts) / 2;

	currentMove = move;
	currentActionPoints = actionPoints;
	currentHP = healthPoints;
	currentSanity = sanity;
	currentMana = mana;
	currentFortuneCards = fortuneCards;

	tempAttackBonus = 0;
	attackBonus = 0;
	tempDamageBonus = 0;
	damageBonus = 0;
	damageRolled = 0;
	attackRolled = 0;

	currentMoveBonus = 0;
	maxMoveBonus = 0;
	currentDefenseBonus = 0;
	maxDefenseBonus = 0;
	currentRollBonus = 0;
	maxRollBonus = 0;
	//initiative = 0;
	//initiativeBonus = 0;
}


void ALoTECharacter::SetSkills(int nwpolearm, int nw2handed, int nw1handed, int nwlight, int nwthrowing, int nwshooting, int ndodging, int nbrawling, int nantimagic, int nwhiteMagic, int nillusions, int nkriomancy, int nnecromancy, int npiromancy, int ntelekinesis, int ntransmutation, int ndivination, int nsurvival, int ntraps, int ntracking, int nacrobatics, int nriding, int nhealing, int nnavigation, int nswimming, int ninvestigation, int nperception, int nclimbing, int nboating, int nbluff, int nleadership, int netiquette, int npersuasion, int nperformance, int nintimidation, int nforgery, int nthievery, int nlockpicking, int ndisguise, int nstealth, int nhistory, int nengineering, int nlinguistics, int nmagic, int noccultism, int nlaw, int nnature, int ntactics, int nenchanting, int nalchemy, int nartistic, int ncooking, int nsmithing, int ntailoring, int ntrading, int nfurriery)
{
	wpolearm = nwpolearm;
	w2handed = nw2handed;
	w1handed = nw1handed;
	wlight = nwlight;
	wthrowing = nwthrowing;
	wshooting = nwshooting;
	dodging = ndodging;
	brawling = nbrawling;
	antimagic = nantimagic;
	whiteMagic = nwhiteMagic;
	illusions = nillusions;
	kriomancy = nkriomancy;
	necromancy = nnecromancy;
	piromancy = npiromancy;
	telekinesis = ntelekinesis;
	transmutation = ntransmutation;
	divination = ndivination;
	survival = nsurvival;
	traps = ntraps;
	tracking = ntracking;
	acrobatics = nacrobatics;
	riding = nriding;
	healing = nhealing;
	navigation = nnavigation;
	swimming = nswimming;
	investigation = ninvestigation;
	perception = nperception;
	climbing = nclimbing;
	boating = nboating;
	bluff = nbluff;
	leadership = nleadership;
	etiquette = netiquette;
	persuasion = npersuasion;
	performance = nperformance;
	intimidation = nintimidation;
	forgery = nforgery;
	thievery = nthievery;
	lockpicking = nlockpicking;
	disguise = ndisguise;
	stealth = nstealth;
	history = nhistory;
	engineering = nengineering;
	linguistics = nlinguistics;
	magic = nmagic;
	occultism = noccultism;
	law = nlaw;
	nature = nnature;
	tactics = ntactics;
	enchanting = nenchanting;
	alchemy = nalchemy;
	artistic = nartistic;
	cooking = ncooking;
	smithing = nsmithing;
	tailoring = ntailoring;
	trading = ntrading;
	furriery = nfurriery;
}

void ALoTECharacter::InitializeStats(TArray<FString> Stats)
{


	FString tmp;
	characterName = Stats[1];
	tmp = Stats[3];
	if (tmp.IsNumeric())
	{
		gold = FCString::Atoi(*tmp);
	}

	tmp = Stats[5];
	if (tmp.IsNumeric())
	{
		strength = FCString::Atoi(*tmp);
	}

	tmp = Stats[7];
	if (tmp.IsNumeric())
	{
		dexterity = FCString::Atoi(*tmp);
	}

	tmp = Stats[9];
	if (tmp.IsNumeric())
	{
		speed = FCString::Atoi(*tmp);
	}

	tmp = Stats[11];
	if (tmp.IsNumeric())
	{
		endurance = FCString::Atoi(*tmp);
	}

	tmp = Stats[13];
	if (tmp.IsNumeric())
	{
		smarts = FCString::Atoi(*tmp);
	}

	tmp = Stats[15];
	if (tmp.IsNumeric())
	{
		psyche = FCString::Atoi(*tmp);
	}

	tmp = Stats[17];
	if (tmp.IsNumeric())
	{
		senses = FCString::Atoi(*tmp);
	}

	tmp = Stats[19];
	if (tmp.IsNumeric())
	{
		move = FCString::Atoi(*tmp);
	}

	tmp = Stats[21];
	if (tmp.IsNumeric())
	{
		actionPoints = FCString::Atoi(*tmp);
	}

	tmp = Stats[23];
	if (tmp.IsNumeric())
	{
		healthPoints = FCString::Atoi(*tmp);
	}

	tmp = Stats[25];
	if (tmp.IsNumeric())
	{
		resistance = FCString::Atoi(*tmp);
	}

	tmp = Stats[27];
	if (tmp.IsNumeric())
	{
		talentsLimit = FCString::Atoi(*tmp);
	}

	tmp = Stats[29];
	if (tmp.IsNumeric())
	{
		sanity = FCString::Atoi(*tmp);
	}

	tmp = Stats[31];
	if (tmp.IsNumeric())
	{
		fortuneCards = FCString::Atoi(*tmp);
	}

	tmp = Stats[33];
	if (tmp.IsNumeric())
	{
		wpolearm = FCString::Atoi(*tmp);
	}

	tmp = Stats[35];
	if (tmp.IsNumeric())
	{
		w2handed = FCString::Atoi(*tmp);
	}

	tmp = Stats[37];
	if (tmp.IsNumeric())
	{
		w1handed = FCString::Atoi(*tmp);
	}

	tmp = Stats[39];
	if (tmp.IsNumeric())
	{
		wlight = FCString::Atoi(*tmp);
	}

	tmp = Stats[41];
	if (tmp.IsNumeric())
	{
		wthrowing = FCString::Atoi(*tmp);
	}

	tmp = Stats[43];
	if (tmp.IsNumeric())
	{
		wshooting = FCString::Atoi(*tmp);
	}

	tmp = Stats[45];
	if (tmp.IsNumeric())
	{
		dodging = FCString::Atoi(*tmp);
	}

	tmp = Stats[47];
	if (tmp.IsNumeric())
	{
		brawling = FCString::Atoi(*tmp);
	}

	tmp = Stats[49];
	if (tmp.IsNumeric())
	{
		antimagic = FCString::Atoi(*tmp);
	}

	tmp = Stats[51];
	if (tmp.IsNumeric())
	{
		whiteMagic = FCString::Atoi(*tmp);
	}

	tmp = Stats[53];
	if (tmp.IsNumeric())
	{
		illusions = FCString::Atoi(*tmp);
	}

	tmp = Stats[55];
	if (tmp.IsNumeric())
	{
		kriomancy = FCString::Atoi(*tmp);
	}

	tmp = Stats[57];
	if (tmp.IsNumeric())
	{
		necromancy = FCString::Atoi(*tmp);
	}

	tmp = Stats[59];
	if (tmp.IsNumeric())
	{
		piromancy = FCString::Atoi(*tmp);
	}

	tmp = Stats[61];
	if (tmp.IsNumeric())
	{
		telekinesis = FCString::Atoi(*tmp);
	}

	tmp = Stats[63];
	if (tmp.IsNumeric())
	{
		transmutation = FCString::Atoi(*tmp);
	}

	tmp = Stats[65];
	if (tmp.IsNumeric())
	{
		divination = FCString::Atoi(*tmp);
	}

	tmp = Stats[67];
	if (tmp.IsNumeric())
	{
		survival = FCString::Atoi(*tmp);
	}

	tmp = Stats[69];
	if (tmp.IsNumeric())
	{
		traps = FCString::Atoi(*tmp);
	}

	tmp = Stats[71];
	if (tmp.IsNumeric())
	{
		tracking = FCString::Atoi(*tmp);
	}

	tmp = Stats[73];
	if (tmp.IsNumeric())
	{
		acrobatics = FCString::Atoi(*tmp);
	}

	tmp = Stats[75];
	if (tmp.IsNumeric())
	{
		riding = FCString::Atoi(*tmp);
	}

	tmp = Stats[77];
	if (tmp.IsNumeric())
	{
		healing = FCString::Atoi(*tmp);
	}

	tmp = Stats[79];
	if (tmp.IsNumeric())
	{
		navigation = FCString::Atoi(*tmp);
	}

	tmp = Stats[81];
	if (tmp.IsNumeric())
	{
		swimming = FCString::Atoi(*tmp);
	}

	tmp = Stats[83];
	if (tmp.IsNumeric())
	{
		investigation = FCString::Atoi(*tmp);
	}

	tmp = Stats[85];
	if (tmp.IsNumeric())
	{
		perception = FCString::Atoi(*tmp);
	}

	tmp = Stats[87];
	if (tmp.IsNumeric())
	{
		climbing = FCString::Atoi(*tmp);
	}

	tmp = Stats[89];
	if (tmp.IsNumeric())
	{
		boating = FCString::Atoi(*tmp);
	}

	tmp = Stats[91];
	if (tmp.IsNumeric())
	{
		bluff = FCString::Atoi(*tmp);
	}

	tmp = Stats[93];
	if (tmp.IsNumeric())
	{
		leadership = FCString::Atoi(*tmp);
	}

	tmp = Stats[95];
	if (tmp.IsNumeric())
	{
		etiquette = FCString::Atoi(*tmp);
	}

	tmp = Stats[97];
	if (tmp.IsNumeric())
	{
		persuasion = FCString::Atoi(*tmp);
	}

	tmp = Stats[99];
	if (tmp.IsNumeric())
	{
		performance = FCString::Atoi(*tmp);
	}

	tmp = Stats[101];
	if (tmp.IsNumeric())
	{
		intimidation = FCString::Atoi(*tmp);
	}

	tmp = Stats[103];
	if (tmp.IsNumeric())
	{
		forgery = FCString::Atoi(*tmp);
	}

	tmp = Stats[105];
	if (tmp.IsNumeric())
	{
		thievery = FCString::Atoi(*tmp);
	}

	tmp = Stats[107];
	if (tmp.IsNumeric())
	{
		lockpicking = FCString::Atoi(*tmp);
	}

	tmp = Stats[109];
	if (tmp.IsNumeric())
	{
		disguise = FCString::Atoi(*tmp);
	}


	tmp = Stats[113];
	if (tmp.IsNumeric())
	{
		stealth = FCString::Atoi(*tmp);
	}

	tmp = Stats[115];
	if (tmp.IsNumeric())
	{
		history = FCString::Atoi(*tmp);
	}

	tmp = Stats[117];
	if (tmp.IsNumeric())
	{
		engineering = FCString::Atoi(*tmp);
	}

	tmp = Stats[119];
	if (tmp.IsNumeric())
	{
		linguistics = FCString::Atoi(*tmp);
	}

	tmp = Stats[121];
	if (tmp.IsNumeric())
	{
		magic = FCString::Atoi(*tmp);
	}

	tmp = Stats[123];
	if (tmp.IsNumeric())
	{
		occultism = FCString::Atoi(*tmp);
	}

	tmp = Stats[125];
	if (tmp.IsNumeric())
	{
		law = FCString::Atoi(*tmp);
	}

	tmp = Stats[127];
	if (tmp.IsNumeric())
	{
		nature = FCString::Atoi(*tmp);
	}

	tmp = Stats[129];
	if (tmp.IsNumeric())
	{
		tactics = FCString::Atoi(*tmp);
	}

	tmp = Stats[131];
	if (tmp.IsNumeric())
	{
		enchanting = FCString::Atoi(*tmp);
	}

	tmp = Stats[133];
	if (tmp.IsNumeric())
	{
		alchemy = FCString::Atoi(*tmp);
	}

	tmp = Stats[135];
	if (tmp.IsNumeric())
	{
		artistic = FCString::Atoi(*tmp);
	}

	tmp = Stats[137];
	if (tmp.IsNumeric())
	{
		cooking = FCString::Atoi(*tmp);
	}

	tmp = Stats[139];
	if (tmp.IsNumeric())
	{
		smithing = FCString::Atoi(*tmp);
	}

	tmp = Stats[141];
	if (tmp.IsNumeric())
	{
		tailoring = FCString::Atoi(*tmp);
	}

	tmp = Stats[143];
	if (tmp.IsNumeric())
	{
		trading = FCString::Atoi(*tmp);
	}

	tmp = Stats[145];
	if (tmp.IsNumeric())
	{
		furriery = FCString::Atoi(*tmp);
	}

	tmp = Stats[147];
	if (tmp.IsNumeric())
	{
		professionalOther = FCString::Atoi(*tmp);
	}

	tmp = Stats[149];
	if (tmp.IsNumeric())
	{
		PD = FCString::Atoi(*tmp);
	}

	tmp = Stats[151];
	if (tmp.IsNumeric())
	{
		mana = FCString::Atoi(*tmp);
	}

	WUsed = WType::BRAWLING;
	minWeaponDmg = 1 + strength;
	maxWeaponDmg = 1 + strength;
	attRolled = 0;
	dmgRolled = 0;
	maxActions = 2;
	maxPurchasableActions = 2;
	currentPurchasableActions = maxPurchasableActions;
	currentActions = maxActions;
	attackUsed = false;
	catchUsed = false;
	tripUsed = false;
	pushUsed = false;
	disarmUsed = false;
	aimUsed = false;
	spellcastingUsed = false;
	moveUsed = false;
	runUsed = false;

	/*ALoTEHUD* LoTEHUD = Cast<ALoTEHUD>(GetWorld()->GetFirstPlayerController()->GetHUD());
	if (LoTEHUD)
	{
		UE_LOG(LogTemp, Warning, TEXT("HUD ON!"));
		LoTEHUD->SetCurrentHP("2");
		LoTEHUD->SetMaxHP(FString::FromInt(healthPoints));
	} */
}
FString ALoTECharacter::statIntToString(int stat)
{

	return FString::FromInt(stat);
}

int ALoTECharacter::GetMaxHP()
{
	return healthPoints;
}

int ALoTECharacter::GetCurrentHP()
{
	return currentHP;
}

int ALoTECharacter::GetMaxActionPoints()
{
	return actionPoints;
}

int ALoTECharacter::GetCurrentActionPoints()
{
	return currentActionPoints;
}

int ALoTECharacter::GetMaxMove()
{
	return move;
}

int ALoTECharacter::GetCurrentMove()
{
	return currentMove;
}

int ALoTECharacter::GetMaxSanity()
{
	return sanity;
}

int ALoTECharacter::GetCurrentSanity()
{
	return currentSanity;
}

int ALoTECharacter::GetMaxMana()
{
	return mana;
}

int ALoTECharacter::GetCurrentMana()
{
	return currentMana;
}

int ALoTECharacter::GetMaxFortuneCards()
{
	return fortuneCards;
}

void ALoTECharacter::RefreshStats()
{
	currentHP = healthPoints;
	currentMove = move;
	currentActionPoints = actionPoints;
	currentSanity = sanity;
	currentMana = mana;
	currentFortuneCards = fortuneCards;
	attRolled = 0;
	dmgRolled = 0;
	maxActions = 2;
	maxPurchasableActions = 2;
	currentPurchasableActions = maxPurchasableActions;
	currentActions = maxActions;
	attackUsed = false;
	catchUsed = false;
	tripUsed = false;
	pushUsed = false;
	disarmUsed = false;
	aimUsed = false;
	spellcastingUsed = false;
	moveUsed = false;
	runUsed = false;
}

int ALoTECharacter::GetCurrentFortuneCards()
{
	return currentFortuneCards;
}

int ALoTECharacter::GetPD()
{
	return PD;
}

int ALoTECharacter::GetStrength()
{
	return strength;
}

int ALoTECharacter::GetDexterity()
{
	return dexterity;
}

int ALoTECharacter::GetSpeed()
{
	return speed;
}

int ALoTECharacter::GetEndurance()
{
	return endurance;
}

int ALoTECharacter::GetSmarts()
{
	return smarts;
}

int ALoTECharacter::GetPsyche()
{
	return psyche;
}

int ALoTECharacter::GetSenses()
{
	return senses;
}

int ALoTECharacter::GetGold()
{
	return gold;
}

int ALoTECharacter::GetResistance()
{
	return resistance;
}

int ALoTECharacter::GetDmgNegation()
{
	return dmgNegation;
}

int ALoTECharacter::GetTalentsLimit()
{
	return talentsLimit;
}

int ALoTECharacter::GetWPolearm()
{
	return wpolearm;
}

int ALoTECharacter::GetW2Handed()
{
	return w2handed;
}

int ALoTECharacter::GetW1Handed()
{
	return w1handed;
}

int ALoTECharacter::GetWLight()
{
	return wlight;
}

int ALoTECharacter::GetWThrowing()
{
	return wthrowing;
}

int ALoTECharacter::GetWShooting()
{
	return wshooting;
}

int ALoTECharacter::GetDodging()
{
	return dodging;
}

int ALoTECharacter::GetBrawling()
{
	return brawling;
}

int ALoTECharacter::GetAntimagic()
{
	return antimagic;
}

int ALoTECharacter::GetWhiteMagic()
{
	return whiteMagic;
}

int ALoTECharacter::GetIllusions()
{
	return illusions;
}

int ALoTECharacter::GetKriomancy()
{
	return kriomancy;
}

int ALoTECharacter::GetNecromancy()
{
	return necromancy;
}

int ALoTECharacter::GetPiromancy()
{
	return piromancy;
}

int ALoTECharacter::GetTelekinesis()
{
	return telekinesis;
}

int ALoTECharacter::GetTransmutation()
{
	return transmutation;
}

int ALoTECharacter::GetDivination()
{
	return divination;
}

int ALoTECharacter::GetSurvival()
{
	return survival;
}

int ALoTECharacter::GetTraps()
{
	return traps;
}

int ALoTECharacter::GetTracking()
{
	return tracking;
}

int ALoTECharacter::GetRiding()
{
	return riding;
}

int ALoTECharacter::GetHealing()
{
	return healing;
}

int ALoTECharacter::GetNavigation()
{
	return navigation;
}

int ALoTECharacter::GetSwimming()
{
	return swimming;
}

int ALoTECharacter::GetInvestigation()
{
	return investigation;
}

int ALoTECharacter::GetPerception()
{
	return perception;
}

int ALoTECharacter::GetClimbing()
{
	return climbing;
}

int ALoTECharacter::GetBoating()
{
	return boating;
}

int ALoTECharacter::GetBluff()
{
	return bluff;
}

int ALoTECharacter::GetLeadership()
{
	return leadership;
}

int ALoTECharacter::GetEtiquette()
{
	return etiquette;
}

int ALoTECharacter::GetPersuasion()
{
	return persuasion;
}

int ALoTECharacter::GetPerformance()
{
	return performance;
}

int ALoTECharacter::GetIntimidation()
{
	return intimidation;
}

int ALoTECharacter::GetForgery()
{
	return forgery;
}

int ALoTECharacter::GetThievery()
{
	return thievery;
}

int ALoTECharacter::GetLockpicking()
{
	return lockpicking;
}

int ALoTECharacter::GetDisguise()
{
	return disguise;
}

int ALoTECharacter::GetStealth()
{
	return stealth;
}

int ALoTECharacter::GetHistory()
{
	return history;
}

int ALoTECharacter::GetEngineering()
{
	return engineering;
}

int ALoTECharacter::GetLinguistics()
{
	return linguistics;
}

int ALoTECharacter::GetMagic()
{
	return magic;
}

int ALoTECharacter::GetOccultism()
{
	return occultism;
}

int ALoTECharacter::GetLaw()
{
	return law;
}

int ALoTECharacter::GetNature()
{
	return nature;
}

int ALoTECharacter::GetTactics()
{
	return tactics;
}

int ALoTECharacter::GetEnchanting()
{
	return enchanting;
}

int ALoTECharacter::GetAlchemy()
{
	return alchemy;
}

int ALoTECharacter::GetArtistic()
{
	return artistic;
}

int ALoTECharacter::GetCooking()
{
	return cooking;
}

int ALoTECharacter::GetSmithing()
{
	return smithing;
}

int ALoTECharacter::GetTailoring()
{
	return tailoring;
}

int ALoTECharacter::GetTrading()
{
	return trading;
}

int ALoTECharacter::GetFurriery()
{
	return furriery;
}

int ALoTECharacter::GetProfessionalOther()
{
	return professionalOther;
}

FString ALoTECharacter::GetCharacterName()
{
	return characterName;
}

void ALoTECharacter::SetMaxHP(int tmp)
{
	healthPoints = tmp;
}

void ALoTECharacter::SetCurrentHP(int tmp)
{
	if (tmp > healthPoints)
	{
		currentHP = healthPoints;
	} else { currentHP = tmp; }
	
}

void ALoTECharacter::SetMaxActionPoints(int tmp)
{
	actionPoints = tmp;
}

void ALoTECharacter::SetCurrentActionPoints(int tmp)
{
	if (tmp > actionPoints)
	{
		currentActionPoints = actionPoints;
	} else { currentActionPoints = tmp; }
	
}

void ALoTECharacter::SetMaxMove(int tmp)
{
	move = tmp;
}

void ALoTECharacter::SetCurrentMove(int tmp)
{
	currentMove = tmp;
}

void ALoTECharacter::SetMaxSanity(int tmp)
{
	sanity = tmp;
}

void ALoTECharacter::SetCurrentSanity(int tmp)
{
	if (tmp > sanity)
	{
		currentHP = sanity;
	} else { currentSanity = tmp; }
	
}

void ALoTECharacter::SetMaxMana(int tmp)
{
	mana = tmp;
}

void ALoTECharacter::SetCurrentMana(int tmp)
{
	if (tmp > mana)
	{
		currentMana = mana;
	}
	else {
		currentMana = tmp;
	}
	
}

void ALoTECharacter::SetMaxFortuneCards(int tmp)
{
	fortuneCards = tmp;
}

void ALoTECharacter::SetCurrentFortuneCards(int tmp)
{
	currentFortuneCards = tmp;
}

void ALoTECharacter::SetPD(int tmp)
{
	PD = tmp;
}

void ALoTECharacter::SetStrength(int tmp)
{
	strength = tmp;
}

void ALoTECharacter::SetDexterity(int tmp)
{
	dexterity = tmp;
}

void ALoTECharacter::SetSpeed(int tmp)
{
	speed = tmp;
}

void ALoTECharacter::SetEndurance(int tmp)
{
	endurance = tmp;
}

void ALoTECharacter::SetSmarts(int tmp)
{
	smarts = tmp;
}

void ALoTECharacter::SetPsyche(int tmp)
{
	psyche = tmp;
}

void ALoTECharacter::SetSenses(int tmp)
{
	senses = tmp;
}

void ALoTECharacter::SetGold(int tmp)
{
	gold = tmp;
}

void ALoTECharacter::SetResistance(int tmp)
{
	resistance = tmp;
}

void ALoTECharacter::SetDmgNegation(int tmp)
{
	dmgNegation = tmp;
}

void ALoTECharacter::SetTalentsLimit(int tmp)
{
	talentsLimit = tmp;
}

void ALoTECharacter::SetWPolearm(int tmp)
{
	wpolearm = tmp;
}

void ALoTECharacter::SetW2Handed(int tmp)
{
	w2handed = tmp;
}

void ALoTECharacter::SetW1Handed(int tmp)
{
	w1handed = tmp;
}

void ALoTECharacter::SetWLight(int tmp)
{
	wlight = tmp;
}

void ALoTECharacter::SetWThrowing(int tmp)
{
	wthrowing = tmp;
}

void ALoTECharacter::SetWShooting(int tmp)
{
	wshooting = tmp;
}

void ALoTECharacter::SetDodging(int tmp)
{
	dodging = tmp;
}

void ALoTECharacter::SetBrawling(int tmp)
{
	brawling = tmp;
}

void ALoTECharacter::SetAntimagic(int tmp)
{
	antimagic = tmp;
}

void ALoTECharacter::SetWhiteMagic(int tmp)
{
	whiteMagic = tmp;
}

void ALoTECharacter::SetIllusions(int tmp)
{
	illusions = tmp;
}

void ALoTECharacter::SetKriomancy(int tmp)
{
	kriomancy = tmp;
}

void ALoTECharacter::SetNecromancy(int tmp)
{
	necromancy = tmp;
}

void ALoTECharacter::SetPiromancy(int tmp)
{
	piromancy = tmp;
}

void ALoTECharacter::SetTelekinesis(int tmp)
{
	telekinesis = tmp;
}

void ALoTECharacter::SetTransmutation(int tmp)
{
	transmutation = tmp;
}

void ALoTECharacter::SetDivination(int tmp)
{
	divination = tmp;
}

void ALoTECharacter::SetSurvival(int tmp)
{
	survival = tmp;
}

void ALoTECharacter::SetTraps(int tmp)
{
	traps = tmp;
}

void ALoTECharacter::SetTracking(int tmp)
{
	tracking = tmp;
}

void ALoTECharacter::SetRiding(int tmp)
{
	riding = tmp;
}

void ALoTECharacter::SetHealing(int tmp)
{
	healing = tmp;
}

void ALoTECharacter::SetNavigation(int tmp)
{
	navigation = tmp;
}

void ALoTECharacter::SetSwimming(int tmp)
{
	swimming = tmp;
}

void ALoTECharacter::SetInvestigation(int tmp)
{
	investigation = tmp;
}

void ALoTECharacter::SetPerception(int tmp)
{
	perception = tmp;
}

void ALoTECharacter::SetClimbing(int tmp)
{
	climbing = tmp;
}

void ALoTECharacter::SetBoating(int tmp)
{
	boating = tmp;
}

void ALoTECharacter::SetBluff(int tmp)
{
	bluff = tmp;
}

void ALoTECharacter::SetLeadership(int tmp)
{
	leadership = tmp;
}

void ALoTECharacter::SetEtiquette(int tmp)
{
	etiquette = tmp;
}

void ALoTECharacter::SetPersuasion(int tmp)
{
	persuasion = tmp;
}

void ALoTECharacter::SetPerformance(int tmp)
{
	performance = tmp;
}

void ALoTECharacter::SetIntimidation(int tmp)
{
	intimidation = tmp;
}

void ALoTECharacter::SetForgery(int tmp)
{
	forgery = tmp;
}

void ALoTECharacter::SetThievery(int tmp)
{
	thievery = tmp;
}

void ALoTECharacter::SetLockpicking(int tmp)
{
	lockpicking = tmp;
}

void ALoTECharacter::SetDisguise(int tmp)
{
	disguise = tmp;
}

void ALoTECharacter::SetStealth(int tmp)
{
	stealth = tmp;
}

void ALoTECharacter::SetHistory(int tmp)
{
	history = tmp;
}

void ALoTECharacter::SetEngineering(int tmp)
{
	engineering = tmp;
}

void ALoTECharacter::SetLinguistics(int tmp)
{
	linguistics = tmp;
}

void ALoTECharacter::SetMagic(int tmp)
{
	magic = tmp;
}

void ALoTECharacter::SetOccultism(int tmp)
{
	occultism = tmp;
}

void ALoTECharacter::SetLaw(int tmp)
{
	law = tmp;
}

void ALoTECharacter::SetNature(int tmp)
{
	nature = tmp;
}

void ALoTECharacter::SetTactics(int tmp)
{
	tactics = tmp;
}

void ALoTECharacter::SetEnchanting(int tmp)
{
	enchanting = tmp;
}

void ALoTECharacter::SetAlchemy(int tmp)
{
	alchemy = tmp;
}

void ALoTECharacter::SetArtistic(int tmp)
{
	artistic = tmp;
}

void ALoTECharacter::SetCooking(int tmp)
{
	cooking = tmp;
}

void ALoTECharacter::SetSmithing(int tmp)
{
	smithing = tmp;
}

void ALoTECharacter::SetTailoring(int tmp)
{
	tailoring = tmp;
}

void ALoTECharacter::SetTrading(int tmp)
{
	trading = tmp;
}

void ALoTECharacter::SetFurriery(int tmp)
{
	furriery = tmp;
}

void ALoTECharacter::SetProfessionalOther(int tmp)
{
	professionalOther = tmp;
}

int ALoTECharacter::GetAcrobatics()
{
	return acrobatics;
}

void ALoTECharacter::SetAcrobatics(int tmp)
{
	acrobatics = tmp;
}


void ALoTECharacter::ReloadStats(TArray<UTextBlock*> Textblocks)
{
	StatsIntoArrayAlphabetically();
//	FString tmp;
//	int tmp2;
	for (int i=0; i<65;i++)
	{
		//tmp2 = CStats[i];
		//tmp = FString::FromInt(tmp2);
		//UE_LOG(LogTemp, Warning, TEXT("shit2 is %s"), *tmp);
		Textblocks[i]->SetText(FText::FromString(FString::FromInt(CStats[i])));
	}
		//Textblocks[0]->SetText(FText::FromString(FString::FromInt(acrobatics)));

	
}  

void ALoTECharacter::StatsIntoArrayAlphabetically()
{
	int elka = 7;
	CStats.Add(5);
	CStats.Add(elka);
	CStats[0]=acrobatics;
	CStats.Add(alchemy);
	CStats.Add(antimagic);
	CStats.Add(artistic);
	CStats.Add(bluff);
	CStats.Add(boating);
	CStats.Add(brawling);
	CStats.Add(climbing);
	CStats.Add(cooking);
	CStats.Add(dexterity);
	CStats.Add(disguise);
	CStats.Add(divination);
	CStats.Add(dodging);
	CStats.Add(enchanting);
	CStats.Add(endurance);
	CStats.Add(engineering);
	CStats.Add(etiquette);
	CStats.Add(forgery);
	CStats.Add(furriery);
	CStats.Add(healing);
	CStats.Add(history);
	CStats.Add(illusions);
	CStats.Add(intimidation);
	CStats.Add(investigation);
	CStats.Add(kriomancy);
	CStats.Add(law);
	CStats.Add(leadership);
	CStats.Add(linguistics);
	CStats.Add(lockpicking);
	CStats.Add(magic);
	CStats.Add(nature);
	CStats.Add(navigation);
	CStats.Add(necromancy);
	CStats.Add(occultism);
	CStats.Add(PD);
	CStats.Add(perception);
	CStats.Add(performance);
	CStats.Add(persuasion);
	CStats.Add(piromancy);
	CStats.Add(professionalOther);
	CStats.Add(psyche);
	CStats.Add(riding);
	CStats.Add(senses);
	CStats.Add(smarts);
	CStats.Add(smithing);
	CStats.Add(speed);
	CStats.Add(stealth);
	CStats.Add(strength);
	CStats.Add(survival);
	CStats.Add(swimming);
	CStats.Add(tactics);
	CStats.Add(tailoring);
	CStats.Add(telekinesis);
	CStats.Add(thievery);
	CStats.Add(tracking);
	CStats.Add(trading);
	CStats.Add(transmutation);
	CStats.Add(traps);
	CStats.Add(w1handed);
	CStats.Add(w2handed);
	CStats.Add(whiteMagic);
	CStats.Add(wlight);
	CStats.Add(wpolearm);
	CStats.Add(wshooting);
	CStats.Add(wthrowing);
	CStats.Add(gold);
	CStats[0] = acrobatics;
	CStats[1] = alchemy;
	CStats[2] = antimagic;
	CStats[3] = artistic;
	CStats[4] = bluff;
	CStats[5] = boating;
	CStats[6] = brawling;
	CStats[7] = climbing;
	CStats[8] = cooking;
	CStats[9] = dexterity;
	CStats[10] = disguise;
	CStats[11] = divination;
	CStats[12] = dodging;
	CStats[13] = enchanting;
	CStats[14] = endurance;
	CStats[15] = engineering;
	CStats[16] = etiquette;
	CStats[17] = forgery;
	CStats[18] = furriery;
	CStats[19] = healing;
	CStats[20] = history;
	CStats[21] = illusions;
	CStats[22] = intimidation;
	CStats[23] = investigation;
	CStats[24] = kriomancy;
	CStats[25] = law;
	CStats[26] = leadership;
	CStats[27] = linguistics;
	CStats[28] = lockpicking;
	CStats[29] = magic;
	CStats[30] = nature;
	CStats[31] = navigation;
	CStats[32] = necromancy;
	CStats[33] = occultism;
	CStats[34] = PD;
	CStats[35] = perception;
	CStats[36] = performance;
	CStats[37] = persuasion;
	CStats[38] = piromancy;
	CStats[39] = professionalOther;
	CStats[40] = psyche;
	CStats[41] = riding;
	CStats[42] = senses;
	CStats[43] = smarts;
	CStats[44] = smithing;
	CStats[45] = speed;
	CStats[46] = stealth;
	CStats[47] = strength;
	CStats[48] = survival;
	CStats[49] = swimming;
	CStats[50] = tactics;
	CStats[51] = tailoring;
	CStats[52] = telekinesis;
	CStats[53] = thievery;
	CStats[54] = tracking;
	CStats[55] = trading;
	CStats[56] = transmutation;
	CStats[57] = traps;
	CStats[58] = w1handed;
	CStats[59] = w2handed;
	CStats[60] = whiteMagic;
	CStats[61] = wlight;
	CStats[62] = wpolearm;
	CStats[63] = wshooting;
	CStats[64] = wthrowing;
	CStats[65] = gold;
}
int ALoTECharacter::RollSkill(int skillLevel, int statLevel)
{
	int minValue, maxValue;
	minValue = skillLevel + statLevel;
	maxValue = minValue;
	int rollBonuses;
	rollBonuses = skillLevel + statLevel + currentRollBonus;

	if (skillLevel == 1)
	{
		minValue = rollBonuses + 2;
		maxValue = rollBonuses + 8;
	}
	else if (skillLevel == 2)
	{
		minValue = rollBonuses + 2;
		maxValue = rollBonuses + 10;
	}
	else if (skillLevel == 3)
	{
		minValue = rollBonuses + 2;
		maxValue = rollBonuses + 12;
	}
	else if (skillLevel == 4)
	{
		minValue = rollBonuses + 2;
		maxValue = rollBonuses + 14;
	}
	else if (skillLevel == 5)
	{
		minValue = rollBonuses + 2;
		maxValue = rollBonuses + 16;
	}
	else if (skillLevel == 6)
	{
		minValue = rollBonuses + 2;
		maxValue = rollBonuses + 18;
	}
	else if (skillLevel == 7)
	{
		minValue = rollBonuses + 2;
		maxValue = rollBonuses + 20;
	}
	else if (skillLevel == 8)
	{
		minValue = rollBonuses + 2;
		maxValue = rollBonuses + 22;
	}
	else if (skillLevel == 9)
	{
		minValue = rollBonuses + 2;
		maxValue = rollBonuses + 24;
	}
	else if (skillLevel == 10)
	{
		minValue = rollBonuses + 3;
		maxValue = rollBonuses + 28;
	}
	else
	{
		minValue = rollBonuses + 1;
		maxValue = rollBonuses + 4;
	}
	return FMath::RandRange(minValue, maxValue);
}

int ALoTECharacter::RollStat(int statLevel)
{
	return FMath::RandRange(statLevel+2, statLevel+12);
	
}

int ALoTECharacter::Roll(int minNumber, int maxNumber)
{
	return FMath::RandRange(minNumber, maxNumber);;
}

int ALoTECharacter::RollWPolearm()
{
	return RollSkill(wpolearm, dexterity);
}

int ALoTECharacter::RollW2Handed()
{
	return RollSkill(w2handed, dexterity);
}

int ALoTECharacter::RollW1Handed()
{
	return RollSkill(w1handed, dexterity);
}

int ALoTECharacter::RollWLight()
{
	return RollSkill(wlight, dexterity);
}

int ALoTECharacter::RollWThrowing()
{
	return RollSkill(wthrowing, dexterity);
}

int ALoTECharacter::RollWShooting()
{
	return RollSkill(wshooting, dexterity);
}

int ALoTECharacter::RollDodging()
{
	return RollSkill(dodging, dexterity);
}

int ALoTECharacter::RollBrawling()
{
	return RollSkill(brawling, dexterity);
}

int ALoTECharacter::RollAntimagic()
{
	return RollSkill(antimagic, senses);
}

int ALoTECharacter::RollWhiteMagic()
{
	return RollSkill(whiteMagic, senses);
}

int ALoTECharacter::RollIllusions()
{
	return RollSkill(illusions, senses);
}

int ALoTECharacter::RollKriomancy()
{
	return RollSkill(kriomancy, senses);
}

int ALoTECharacter::RollNecromancy()
{
	return RollSkill(necromancy, senses);
}

int ALoTECharacter::RollPiromancy()
{
	return RollSkill(piromancy, senses);
}

int ALoTECharacter::RollTelekinesis()
{
	return RollSkill(telekinesis, senses);
}

int ALoTECharacter::RollTransmutation()
{
	return RollSkill(transmutation, senses);
}

int ALoTECharacter::RollDivination()
{
	return RollSkill(divination, senses);
}

int ALoTECharacter::RollSurvival()
{
	return RollSkill(survival, senses);
}

int ALoTECharacter::RollTraps()
{
	return RollSkill(traps, smarts);
}

int ALoTECharacter::RollTracking()
{
	return RollSkill(tracking, senses);
}

int ALoTECharacter::RollRiding()
{
	return RollSkill(riding, dexterity);
}

int ALoTECharacter::RollHealing()
{
	return RollSkill(healing, dexterity);
}

int ALoTECharacter::RollNavigation()
{
	return RollSkill(navigation, smarts);
}

int ALoTECharacter::RollSwimming()
{
	return RollSkill(swimming, strength);
}

int ALoTECharacter::RollInvestigation()
{
	return RollSkill(investigation, smarts);
}

int ALoTECharacter::RollPerception()
{
	return RollSkill(perception, senses);
}

int ALoTECharacter::RollClimbing()
{
	return RollSkill(climbing, strength);
}

int ALoTECharacter::RollBoating()
{
	return RollSkill(boating, dexterity);
}

int ALoTECharacter::RollBluff()
{
	return RollSkill(bluff, senses);
}

int ALoTECharacter::RollLeadership()
{
	return RollSkill(leadership, senses);
}

int ALoTECharacter::RollEtiquette()
{
	return RollSkill(etiquette, senses);
}

int ALoTECharacter::RollPersuasion()
{
	return RollSkill(persuasion, senses);
}

int ALoTECharacter::RollPerformance()
{
	return RollSkill(performance, senses);
}

int ALoTECharacter::RollIntimidation()
{
	return RollSkill(intimidation, senses);
}

int ALoTECharacter::RollForgery()
{
	return RollSkill(forgery, dexterity);
}

int ALoTECharacter::RollThievery()
{
	return RollSkill(thievery, dexterity);
}

int ALoTECharacter::RollLockpicking()
{
	return RollSkill(lockpicking, dexterity);
}

int ALoTECharacter::RollDisguise()
{
	return RollSkill(disguise, smarts);
}

int ALoTECharacter::RollStealth()
{
	return RollSkill(stealth, dexterity);
}

int ALoTECharacter::RollHistory()
{
	return RollSkill(history, smarts);
}

int ALoTECharacter::RollEngineering()
{
	return RollSkill(engineering, smarts);
}

int ALoTECharacter::RollLinguistics()
{
	return RollSkill(linguistics, smarts);
}

int ALoTECharacter::RollMagic()
{
	return RollSkill(magic, smarts);
}

int ALoTECharacter::RollOccultism()
{
	return RollSkill(occultism, smarts);
}

int ALoTECharacter::RollLaw()
{
	return RollSkill(law, smarts);
}

int ALoTECharacter::RollNature()
{
	return RollSkill(nature, smarts);
}

int ALoTECharacter::RollTactics()
{
	return RollSkill(tactics, smarts);
}

int ALoTECharacter::RollEnchanting()
{
	return RollSkill(enchanting, smarts);
}

int ALoTECharacter::RollAlchemy()
{
	return RollSkill(alchemy, smarts);
}

int ALoTECharacter::RollArtistic()
{
	return RollSkill(artistic, senses);
}

int ALoTECharacter::RollCooking()
{
	return RollSkill(cooking, smarts);
}

int ALoTECharacter::RollSmithing()
{
	return RollSkill(smithing, dexterity);
}

int ALoTECharacter::RollTailoring()
{
	return RollSkill(tailoring, dexterity);
}

int ALoTECharacter::RollTrading()
{
	return RollSkill(trading, smarts);
}

int ALoTECharacter::RollFurriery()
{
	return RollSkill(furriery, dexterity);
}

int ALoTECharacter::RollProfessionalOther()
{
	return RollSkill(professionalOther, smarts);
}

int ALoTECharacter::RollAcrobatics()
{
	return RollSkill(acrobatics, dexterity);
}

int ALoTECharacter::Attack()
{
	if (WUsed == WType::BRAWLING)
	{
		attRolled =RollBrawling();
	}
	else if (WUsed == WType::ONEHANDED)
	{
		attRolled = RollW1Handed();
	}
	else if (WUsed == WType::POLEARM)
	{
		attRolled = RollWPolearm();
	}
	else if (WUsed == WType::SHOOTING)
	{
		attRolled = RollWShooting();
	}
	else if (WUsed == WType::SHORT)
	{
		attRolled = RollWLight();
	}
	else if (WUsed == WType::THROWING)
	{
		attRolled = RollWThrowing();
	}
	else if (WUsed == WType::TWOHANDED)
	{
		attRolled = RollW2Handed();
	}

	
	return attRolled;
}

int ALoTECharacter::RollStrength()
{
	return RollStat(strength);
}

int ALoTECharacter::RollDexterity()
{
	return RollStat(dexterity);
}

int ALoTECharacter::RollSpeed()
{
	return RollStat(speed);
}

int ALoTECharacter::RollEndurance()
{
	return RollStat(endurance);
}

int ALoTECharacter::RollSmarts()
{
	return RollStat(smarts);
}

int ALoTECharacter::RollPsyche()
{
	return RollStat(psyche);
}

int ALoTECharacter::RollSenses()
{
	return RollStat(senses);
}

void ALoTECharacter::SetCharacterName(FString name)
{
	characterName = name;
}

int ALoTECharacter::RollDamage()
{
	dmgRolled = Roll(minWeaponDmg, maxWeaponDmg);
	return dmgRolled;
}

int ALoTECharacter::RollParry()
{
	return Attack();
}

bool ALoTECharacter::CheckIfDead()
{
	int hp = GetCurrentHP();
	if (hp < 1)
		return true;
	return false;
}

void ALoTECharacter::DoYourTurn_Implementation()
{
}

Is that the full error message?

Yes, it is.

I suppose that this is an engine bug (because compilation from visual studio works flawlessly, and compilation from engine works sometimes) but I’m still curious if anyone before me found a solution. It’s tiring to compile 5-10 times to do it successfully

So it compiles successfully in VS but not VS Code, is that what you’re saying?

No. It compiles succesfuly in VS but not in the Engine after clicking the “compile” button. Like, 8 ot of 10 times when I click the “compile” (the one next to “build”, because the little “compile” in blueprints work well) it crashes with the error message from my first post.

When you’re compiling with VS, is that with the editor closed? If so then that sounds like an issue with hot reloading which makes sense since it’s mentioned in the crash report.

Yeah, that’s right. Do you know how to resolve said issue?

Not quite, would you be willing to send your project?

Well, word of warning… It’s huge. Like 40gb unzipped right now. Saved, Binaries and Intermediate folders are about 20gb, so I think zipped project would be around 8-10. Are you really up to do this?

You don’t need to send the binaries and intermediate folders. So before sending could you try deleting them to see if that was the issue? If not then please use File > Package Project > Zip Up Project as this will only zip up only files that are needed.