void FShooterOptions::TellInputAboutKeybindings()
{
UShooterPersistentUser* PersistentUser = GetPersistentUser();
if(PersistentUser)
{
PersistentUser->TellInputAboutKeybindings();
}
}
void FAmethystOptions::TellInputAboutKeybindings()
{
UAmethystPersistentUser* PersistentUser = GetPersistentUser();
if(PersistentUser)
{
PersistentUser->TellInputAboutKeybindings();
}
}
void FShooterMainMenu::BotCountOptionChanged(TSharedPtr<FShooterMenuItem> MenuItem, int32 MultiOptionIndex)
{
BotsCountOpt = MultiOptionIndex;
UShooterPersistentUser* PersistentUser = GetPersistentUser();
if(PersistentUser)
{
PersistentUser->SetBotsCount(BotsCountOpt);
}
}
void AShooterPlayerController::InitInputSystem()
{
Super::InitInputSystem();
UShooterPersistentUser* PersistentUser = GetPersistentUser();
if(PersistentUser)
{
PersistentUser->TellInputAboutKeybindings();
}
}
int32 FShooterOptions::GetCurrentMouseYAxisInvertedIndex()
{
UShooterPersistentUser* PersistentUser = GetPersistentUser();
if(PersistentUser)
{
return InvertYAxisOption->SelectedMultiChoice = PersistentUser->GetInvertedYAxis() ? 1 : 0;
}
else
{
return 0;
}
}
int32 FShooterOptions::GetCurrentGammaIndex()
{
UShooterPersistentUser* PersistentUser = GetPersistentUser();
if(PersistentUser)
{
//reverse gamma calculation
int32 GammaIndex = FMath::TruncToInt(((PersistentUser->GetGamma() - 2.2f) / 2.0f + 0.5f) * 100);
//Clamp to valid index range
return FMath::Clamp(GammaIndex, 0, 100);
}
return FMath::TruncToInt(((2.2f - 2.2f) / 2.0f + 0.5f) * 100);
}
int32 FShooterOptions::GetCurrentMouseSensitivityIndex()
{
UShooterPersistentUser* PersistentUser = GetPersistentUser();
if(PersistentUser)
{
//mouse sensitivity is a floating point value ranged from 0.0f to 1.0f
int32 IntSensitivity = FMath::RoundToInt((PersistentUser->GetAimSensitivity() - 0.5f) * 10.0f);
//Clamp to valid index range
return FMath::Clamp(IntSensitivity, MinSensitivity, 100);
}
return FMath::RoundToInt((1.0f - 0.5f) * 10.0f);
}
void AShooterPlayerController::GameHasEnded(class AActor* EndGameFocus, bool bIsWinner)
{
// write stats
ULocalPlayer* LocalPlayer = Cast<ULocalPlayer>(Player);
if (LocalPlayer)
{
AShooterPlayerState* ShooterPlayerState = Cast<AShooterPlayerState>(PlayerState);
if (ShooterPlayerState)
{
// update local saved profile
UShooterPersistentUser* const PersistentUser = GetPersistentUser();
if (PersistentUser)
{
PersistentUser->AddMatchResult( ShooterPlayerState->GetKills(), ShooterPlayerState->GetDeaths(), ShooterPlayerState->GetNumBulletsFired(), ShooterPlayerState->GetNumRocketsFired(), bIsWinner);
PersistentUser->SaveIfDirty();
}
// update achievements
UpdateAchievementsOnGameEnd();
// update leaderboards
IOnlineSubsystem* const OnlineSub = IOnlineSubsystem::Get();
if(OnlineSub)
{
IOnlineIdentityPtr Identity = OnlineSub->GetIdentityInterface();
if (Identity.IsValid())
{
TSharedPtr<FUniqueNetId> UserId = Identity->GetUniquePlayerId(LocalPlayer->ControllerId);
if (UserId.IsValid())
{
IOnlineLeaderboardsPtr Leaderboards = OnlineSub->GetLeaderboardsInterface();
if (Leaderboards.IsValid())
{
FShooterAllTimeMatchResultsWrite WriteObject;
WriteObject.SetIntStat(LEADERBOARD_STAT_SCORE, ShooterPlayerState->GetKills());
WriteObject.SetIntStat(LEADERBOARD_STAT_KILLS, ShooterPlayerState->GetKills());
WriteObject.SetIntStat(LEADERBOARD_STAT_DEATHS, ShooterPlayerState->GetDeaths());
WriteObject.SetIntStat(LEADERBOARD_STAT_MATCHESPLAYED, 1);
// the call will copy the user id and write object to its own memory
Leaderboards->WriteLeaderboards(ShooterPlayerState->SessionName, *UserId, WriteObject);
}
}
}
}
}
}
Super::GameHasEnded(EndGameFocus, bIsWinner);
}
void FAmethystOptions::ApplySettings()
{
UAmethystPersistentUser* PersistentUser = GetPersistentUser();
if(PersistentUser)
{
PersistentUser->SetAimSensitivity(SensitivityOpt);
PersistentUser->SetInvertedYAxis(bInvertYAxisOpt);
PersistentUser->SetGamma(GammaOpt);
PersistentUser->TellInputAboutKeybindings();
PersistentUser->SaveIfDirty();
}
UserSettings->SetScreenResolution(ResolutionOpt);
UserSettings->SetFullscreenMode(bFullScreenOpt);
UserSettings->SetGraphicsQuality(GraphicsQualityOpt);
UserSettings->ApplySettings(false);
OnApplyChanges.ExecuteIfBound();
}
void FAmethystOptions::UpdateOptions()
{
#if UE_BUILD_SHIPPING
CheatsItem->bVisible = false;
#else
//Toggle Cheat menu visibility depending if we are client or server
UWorld* const World = PlayerOwner->GetWorld();
if (World && World->GetNetMode() == NM_Client)
{
CheatsItem->bVisible = false;
}
else
{
CheatsItem->bVisible = true;
}
#endif
//grab the user settings
UAmethystPersistentUser* const PersistentUser = GetPersistentUser();
if (PersistentUser)
{
// Update bInvertYAxisOpt, SensitivityOpt and GammaOpt because the AmethystOptions can be created without the controller having a player
// by the in-game menu which will leave them with default values
bInvertYAxisOpt = PersistentUser->GetInvertedYAxis();
SensitivityOpt = PersistentUser->GetAimSensitivity();
GammaOpt = PersistentUser->GetGamma();
}
InvertYAxisOption->SelectedMultiChoice = GetCurrentMouseYAxisInvertedIndex();
AimSensitivityOption->SelectedMultiChoice = GetCurrentMouseSensitivityIndex();
GammaOption->SelectedMultiChoice = GetCurrentGammaIndex();
#if PLATFORM_DESKTOP
VideoResolutionOption->SelectedMultiChoice = GetCurrentResolutionIndex(UserSettings->GetScreenResolution());
GraphicsQualityOption->SelectedMultiChoice = UserSettings->GetGraphicsQuality();
FullScreenOption->SelectedMultiChoice = UserSettings->GetCurrentFullscreenMode() != EWindowMode::Windowed ? 1 : 0;
#endif
}
void FShooterOptions::Construct(ULocalPlayer* _PlayerOwner)
{
OptionsStyle = &FShooterStyle::Get().GetWidgetStyle<FShooterOptionsStyle>("DefaultShooterOptionsStyle");
PlayerOwner = _PlayerOwner;
MinSensitivity = 1;
TArray<FText> ResolutionList;
TArray<FText> OnOffList;
TArray<FText> SensitivityList;
TArray<FText> GammaList;
TArray<FText> LowHighList;
FDisplayMetrics DisplayMetrics;
FSlateApplication::Get().GetInitialDisplayMetrics(DisplayMetrics);
bool bAddedNativeResolution = false;
const FIntPoint NativeResolution(DisplayMetrics.PrimaryDisplayWidth, DisplayMetrics.PrimaryDisplayHeight);
for (int32 i = 0; i < DefaultShooterResCount; i++)
{
if (DefaultShooterResolutions[i].X <= DisplayMetrics.PrimaryDisplayWidth && DefaultShooterResolutions[i].Y <= DisplayMetrics.PrimaryDisplayHeight)
{
ResolutionList.Add(FText::Format(FText::FromString("{0}x{1}"), FText::FromString(FString::FromInt(DefaultShooterResolutions[i].X)), FText::FromString(FString::FromInt(DefaultShooterResolutions[i].Y))));
Resolutions.Add(DefaultShooterResolutions[i]);
bAddedNativeResolution = bAddedNativeResolution || (DefaultShooterResolutions[i] == NativeResolution);
}
}
// Always make sure that the native resolution is available
if (!bAddedNativeResolution)
{
ResolutionList.Add(FText::Format(FText::FromString("{0}x{1}"), FText::FromString(FString::FromInt(NativeResolution.X)), FText::FromString(FString::FromInt(NativeResolution.Y))));
Resolutions.Add(NativeResolution);
}
OnOffList.Add(LOCTEXT("Off","OFF"));
OnOffList.Add(LOCTEXT("On","ON"));
LowHighList.Add(LOCTEXT("Low","LOW"));
LowHighList.Add(LOCTEXT("High","HIGH"));
//Mouse sensitivity 0-50
for (int32 i = 0; i < 51; i++)
{
SensitivityList.Add(FText::AsNumber(i));
}
for (int32 i = -50; i < 51; i++)
{
GammaList.Add(FText::AsNumber(i));
}
/** Options menu root item */
TSharedPtr<FShooterMenuItem> OptionsRoot = FShooterMenuItem::CreateRoot();
/** Cheats menu root item */
TSharedPtr<FShooterMenuItem> CheatsRoot = FShooterMenuItem::CreateRoot();
CheatsItem = MenuHelper::AddMenuItem(CheatsRoot,LOCTEXT("Cheats", "CHEATS"));
MenuHelper::AddMenuOptionSP(CheatsItem, LOCTEXT("InfiniteAmmo", "INFINITE AMMO"), OnOffList, this, &FShooterOptions::InfiniteAmmoOptionChanged);
MenuHelper::AddMenuOptionSP(CheatsItem, LOCTEXT("InfiniteClip", "INFINITE CLIP"), OnOffList, this, &FShooterOptions::InfiniteClipOptionChanged);
MenuHelper::AddMenuOptionSP(CheatsItem, LOCTEXT("FreezeMatchTimer", "FREEZE MATCH TIMER"), OnOffList, this, &FShooterOptions::FreezeTimerOptionChanged);
MenuHelper::AddMenuOptionSP(CheatsItem, LOCTEXT("HealthRegen", "HP REGENERATION"), OnOffList, this, &FShooterOptions::HealthRegenOptionChanged);
OptionsItem = MenuHelper::AddMenuItem(OptionsRoot,LOCTEXT("Options", "OPTIONS"));
#if PLATFORM_DESKTOP
VideoResolutionOption = MenuHelper::AddMenuOptionSP(OptionsItem,LOCTEXT("Resolution", "RESOLUTION"), ResolutionList, this, &FShooterOptions::VideoResolutionOptionChanged);
GraphicsQualityOption = MenuHelper::AddMenuOptionSP(OptionsItem,LOCTEXT("Quality", "QUALITY"),LowHighList, this, &FShooterOptions::GraphicsQualityOptionChanged);
FullScreenOption = MenuHelper::AddMenuOptionSP(OptionsItem,LOCTEXT("FullScreen", "FULL SCREEN"),OnOffList, this, &FShooterOptions::FullScreenOptionChanged);
#endif
GammaOption = MenuHelper::AddMenuOptionSP(OptionsItem,LOCTEXT("Gamma", "GAMMA CORRECTION"),GammaList, this, &FShooterOptions::GammaOptionChanged);
AimSensitivityOption = MenuHelper::AddMenuOptionSP(OptionsItem,LOCTEXT("AimSensitivity", "AIM SENSITIVITY"),SensitivityList, this, &FShooterOptions::AimSensitivityOptionChanged);
InvertYAxisOption = MenuHelper::AddMenuOptionSP(OptionsItem,LOCTEXT("InvertYAxis", "INVERT Y AXIS"),OnOffList, this, &FShooterOptions::InvertYAxisOptionChanged);
MenuHelper::AddMenuItemSP(OptionsItem,LOCTEXT("ApplyChanges", "APPLY CHANGES"), this, &FShooterOptions::OnApplySettings);
//Do not allow to set aim sensitivity to 0
AimSensitivityOption->MinMultiChoiceIndex = MinSensitivity;
UserSettings = CastChecked<UShooterGameUserSettings>(GEngine->GetGameUserSettings());
ResolutionOpt = UserSettings->GetScreenResolution();
bFullScreenOpt = UserSettings->GetFullscreenMode();
GraphicsQualityOpt = UserSettings->GetGraphicsQuality();
UShooterPersistentUser* PersistentUser = GetPersistentUser();
if(PersistentUser)
{
bInvertYAxisOpt = PersistentUser->GetInvertedYAxis();
SensitivityOpt = PersistentUser->GetAimSensitivity();
GammaOpt = PersistentUser->GetGamma();
}
else
{
bInvertYAxisOpt = false;
SensitivityOpt = 1.0f;
GammaOpt = 2.2f;
}
}
void FShooterMainMenu::Construct(APlayerController* _PCOwner, AShooterGame_Menu* _SGOwner)
{
bShowingDownloadPct = false;
PCOwner = _PCOwner;
SGOwner = _SGOwner;
// read user settings
UShooterGameUserSettings* const UserSettings = CastChecked<UShooterGameUserSettings>(GEngine->GetGameUserSettings());
bIsLanMatch = UserSettings->IsLanMatch();
UShooterPersistentUser* PersistentUser = GetPersistentUser();
BotsCountOpt = 1;
if(PersistentUser)
{
BotsCountOpt = PersistentUser->GetBotsCount();
}
// number entries 0 up to MAX_BOX_COUNT
TArray<FText> BotsCountList;
for (int32 i = 0; i <= MAX_BOT_COUNT; i++)
{
BotsCountList.Add(FText::AsNumber(i));
}
TArray<FText> MapList;
for (int32 i = 0; i < ARRAY_COUNT(MapNames); ++i)
{
MapList.Add(FText::FromString(MapNames[i]));
}
TArray<FText> OnOffList;
OnOffList.Add( LOCTEXT("Off","OFF") );
OnOffList.Add( LOCTEXT("On","ON") );
ShooterOptions = MakeShareable(new FShooterOptions());
ShooterOptions->Construct(PCOwner);
ShooterOptions->TellInputAboutKeybindings();
ShooterOptions->OnApplyChanges.BindSP(this, &FShooterMainMenu::CloseSubMenu);
//Now that we are here, build our menu
MenuWidget.Reset();
MenuWidgetContainer.Reset();
if (GEngine && GEngine->GameViewport)
{
SAssignNew(MenuWidget, SShooterMenuWidget)
.Cursor(EMouseCursor::Default)
.PCOwner(TWeakObjectPtr<APlayerController>(PCOwner))
.GameModeOwner(SGOwner)
.IsGameMenu(false);
SAssignNew(MenuWidgetContainer, SWeakWidget)
.PossiblyNullContent(MenuWidget);
TSharedPtr<FShooterMenuItem> RootMenuItem;
SAssignNew(SplitScreenLobbyWidget, SShooterSplitScreenLobby)
.LocalPlayer(_PCOwner)
.OnCancelClicked(FOnClicked::CreateSP(this, &FShooterMainMenu::OnSplitScreenBackedOut))
.OnPlayClicked(FOnClicked::CreateSP(this, &FShooterMainMenu::OnSplitScreenPlay));
SAssignNew(SplitScreenLobbyWidgetContainer, SWeakWidget)
.PossiblyNullContent(SplitScreenLobbyWidget);
#if SHOOTER_CONSOLE_UI
// PLAY menu option
TSharedPtr<FShooterMenuItem> PlaySubMenu = MenuHelper::AddMenuItem(RootMenuItem, LOCTEXT("Play", "PLAY"));
// submenu under "play"
MenuHelper::AddMenuItemSP(PlaySubMenu, LOCTEXT("TDM", "TEAM DEATHMATCH"), this, &FShooterMainMenu::OnSplitScreenSelected);
TSharedPtr<FShooterMenuItem> NumberOfBotsOption = MenuHelper::AddMenuOptionSP(PlaySubMenu, LOCTEXT("NumberOfBots", "NUMBER OF BOTS"), BotsCountList, this, &FShooterMainMenu::BotCountOptionChanged);
NumberOfBotsOption->SelectedMultiChoice = BotsCountOpt;
MapOption = MenuHelper::AddMenuOption(PlaySubMenu, LOCTEXT("SELECTED_LEVEL", "Map"), MapList);
MapOption->SelectedMultiChoice = DefaultTDMMap;
#else
// HOST menu option
TSharedPtr<FShooterMenuItem> MenuItem;
MenuItem = MenuHelper::AddMenuItem(RootMenuItem, LOCTEXT("Host", "HOST"));
// submenu under "host"
MenuHelper::AddMenuItemSP(MenuItem, LOCTEXT("FFA", "FREE FOR ALL"), this, &FShooterMainMenu::OnUIHostFreeForAll);
MenuHelper::AddMenuItemSP(MenuItem, LOCTEXT("TDM", "TEAM DEATHMATCH"), this, &FShooterMainMenu::OnUIHostTeamDeathMatch);
TSharedPtr<FShooterMenuItem> NumberOfBotsOption = MenuHelper::AddMenuOptionSP(MenuItem, LOCTEXT("NumberOfBots", "NUMBER OF BOTS"), BotsCountList, this, &FShooterMainMenu::BotCountOptionChanged);
NumberOfBotsOption->SelectedMultiChoice = BotsCountOpt;
MapOption = MenuHelper::AddMenuOption(MenuItem, LOCTEXT("SELECTED_LEVEL", "Map"), MapList);
HostLANItem = MenuHelper::AddMenuOptionSP(MenuItem, LOCTEXT("LanMatch", "LAN"), OnOffList, this, &FShooterMainMenu::LanMatchChanged);
HostLANItem->SelectedMultiChoice = bIsLanMatch;
// JOIN menu option
MenuItem = MenuHelper::AddMenuItem(RootMenuItem, LOCTEXT("Join", "JOIN"));
// submenu under "join"
MenuHelper::AddMenuItemSP(MenuItem, LOCTEXT("Server", "SERVER"), this, &FShooterMainMenu::OnJoinServer);
JoinLANItem = MenuHelper::AddMenuOptionSP(MenuItem, LOCTEXT("LanMatch", "LAN"), OnOffList, this, &FShooterMainMenu::LanMatchChanged);
JoinLANItem->SelectedMultiChoice = bIsLanMatch;
// Server list widget that will be called up if appropriate
MenuHelper::AddCustomMenuItem(JoinServerItem,SAssignNew(ServerListWidget,SShooterServerList).OwnerWidget(MenuWidget).PCOwner(PCOwner));
#endif
// Leaderboards
#if !SHOOTER_CONSOLE_UI
MenuHelper::AddMenuItemSP(RootMenuItem, LOCTEXT("Leaderboards", "LEADERBOARDS"), this, &FShooterMainMenu::OnShowLeaderboard);
MenuHelper::AddCustomMenuItem(LeaderboardItem,SAssignNew(LeaderboardWidget,SShooterLeaderboard).OwnerWidget(MenuWidget).PCOwner(PCOwner));
#endif
// Options
MenuHelper::AddExistingMenuItem(RootMenuItem, ShooterOptions->OptionsItem.ToSharedRef());
if(FSlateApplication::Get().SupportsSystemHelp())
{
TSharedPtr<FShooterMenuItem> HelpSubMenu = MenuHelper::AddMenuItem(RootMenuItem, LOCTEXT("Help", "HELP"));
HelpSubMenu->OnConfirmMenuItem.BindStatic([](){ FSlateApplication::Get().ShowSystemHelp(); });
}
// QUIT option (for PC)
#if !SHOOTER_CONSOLE_UI
MenuHelper::AddMenuItemSP(RootMenuItem, LOCTEXT("Quit", "QUIT"), this, &FShooterMainMenu::OnUIQuit);
#endif
MenuWidget->CurrentMenuTitle = LOCTEXT("MainMenu","MAIN MENU");
MenuWidget->OnGoBack.BindSP(this, &FShooterMainMenu::OnMenuGoBack);
MenuWidget->MainMenu = MenuWidget->CurrentMenu = RootMenuItem->SubMenu;
MenuWidget->OnMenuHidden.BindSP(this, &FShooterMainMenu::OnMenuHidden);
ShooterOptions->UpdateOptions();
MenuWidget->BuildAndShowMenu();
}
UpdateMenuOwner();
}
void AShooterPlayerController::UpdateAchievementsOnGameEnd()
{
ULocalPlayer* LocalPlayer = Cast<ULocalPlayer>(Player);
if (LocalPlayer)
{
AShooterPlayerState* ShooterPlayerState = Cast<AShooterPlayerState>(PlayerState);
if (ShooterPlayerState)
{
const UShooterPersistentUser* PersistentUser = GetPersistentUser();
if (PersistentUser)
{
const int32 Wins = PersistentUser->GetWins();
const int32 Losses = PersistentUser->GetLosses();
const int32 Matches = Wins + Losses;
const int32 TotalKills = PersistentUser->GetKills();
const int32 MatchScore = (int32)ShooterPlayerState->GetScore();
const int32 TotalBulletsFired = PersistentUser->GetBulletsFired();
const int32 TotalRocketsFired = PersistentUser->GetRocketsFired();
float TotalGameAchievement = 0;
float CurrentGameAchievement = 0;
///////////////////////////////////////
// Kill achievements
{
float fSomeKillPct = ((float)TotalKills / (float)SomeKillsCount) * 100.0f;
fSomeKillPct = FMath::RoundToFloat(fSomeKillPct);
UpdateAchievementProgress(ACH_SOME_KILLS, fSomeKillPct);
CurrentGameAchievement += FMath::Min(fSomeKillPct, 100.0f);
TotalGameAchievement += 100;
}
{
float fLotsKillPct = ((float)TotalKills / (float)LotsKillsCount) * 100.0f;
fLotsKillPct = FMath::RoundToFloat(fLotsKillPct);
UpdateAchievementProgress(ACH_LOTS_KILLS, fLotsKillPct);
CurrentGameAchievement += FMath::Min(fLotsKillPct, 100.0f);
TotalGameAchievement += 100;
}
///////////////////////////////////////
///////////////////////////////////////
// Match Achievements
{
UpdateAchievementProgress(ACH_FINISH_MATCH, 100.0f);
CurrentGameAchievement += 100;
TotalGameAchievement += 100;
}
{
float fLotsRoundsPct = ((float)Matches / (float)LotsMatchesCount) * 100.0f;
fLotsRoundsPct = FMath::RoundToFloat(fLotsRoundsPct);
UpdateAchievementProgress(ACH_LOTS_MATCHES, fLotsRoundsPct);
CurrentGameAchievement += FMath::Min(fLotsRoundsPct, 100.0f);
TotalGameAchievement += 100;
}
///////////////////////////////////////
///////////////////////////////////////
// Win Achievements
if (Wins >= 1)
{
UpdateAchievementProgress(ACH_FIRST_WIN, 100.0f);
CurrentGameAchievement += 100.0f;
}
TotalGameAchievement += 100;
{
float fLotsWinPct = ((float)Wins / (float)LotsWinsCount) * 100.0f;
fLotsWinPct = FMath::RoundToInt(fLotsWinPct);
UpdateAchievementProgress(ACH_LOTS_WIN, fLotsWinPct);
CurrentGameAchievement += FMath::Min(fLotsWinPct, 100.0f);
TotalGameAchievement += 100;
}
{
float fManyWinPct = ((float)Wins / (float)ManyWinsCount) * 100.0f;
fManyWinPct = FMath::RoundToInt(fManyWinPct);
UpdateAchievementProgress(ACH_MANY_WIN, fManyWinPct);
CurrentGameAchievement += FMath::Min(fManyWinPct, 100.0f);
TotalGameAchievement += 100;
}
///////////////////////////////////////
///////////////////////////////////////
// Ammo Achievements
{
float fLotsBulletsPct = ((float)TotalBulletsFired / (float)LotsBulletsCount) * 100.0f;
fLotsBulletsPct = FMath::RoundToFloat(fLotsBulletsPct);
UpdateAchievementProgress(ACH_SHOOT_BULLETS, fLotsBulletsPct);
CurrentGameAchievement += FMath::Min(fLotsBulletsPct, 100.0f);
TotalGameAchievement += 100;
}
{
float fLotsRocketsPct = ((float)TotalRocketsFired / (float)LotsRocketsCount) * 100.0f;
fLotsRocketsPct = FMath::RoundToFloat(fLotsRocketsPct);
UpdateAchievementProgress(ACH_SHOOT_ROCKETS, fLotsRocketsPct);
CurrentGameAchievement += FMath::Min(fLotsRocketsPct, 100.0f);
TotalGameAchievement += 100;
}
///////////////////////////////////////
///////////////////////////////////////
// Score Achievements
{
float fGoodScorePct = ((float)MatchScore / (float)GoodScoreCount) * 100.0f;
fGoodScorePct = FMath::RoundToFloat(fGoodScorePct);
UpdateAchievementProgress(ACH_GOOD_SCORE, fGoodScorePct);
}
{
float fGreatScorePct = ((float)MatchScore / (float)GreatScoreCount) * 100.0f;
fGreatScorePct = FMath::RoundToFloat(fGreatScorePct);
UpdateAchievementProgress(ACH_GREAT_SCORE, fGreatScorePct);
}
///////////////////////////////////////
///////////////////////////////////////
// Map Play Achievements
UWorld* World = GetWorld();
if (World)
{
FString MapName = *FPackageName::GetShortName(World->PersistentLevel->GetOutermost()->GetName());
if (MapName.Find(TEXT("Highrise")) != -1)
{
UpdateAchievementProgress(ACH_PLAY_HIGHRISE, 100.0f);
}
else if (MapName.Find(TEXT("Sanctuary")) != -1)
{
UpdateAchievementProgress(ACH_PLAY_SANCTUARY, 100.0f);
}
}
///////////////////////////////////////
const auto Events = Online::GetEventsInterface();
const auto Identity = Online::GetIdentityInterface();
if (Events.IsValid() && Identity.IsValid())
{
int32 UserIndex = LocalPlayer->ControllerId;
TSharedPtr<FUniqueNetId> UniqueID = Identity->GetUniquePlayerId(UserIndex);
if (UniqueID.IsValid())
{
FOnlineEventParms Params;
float fGamePct = (CurrentGameAchievement / TotalGameAchievement) * 100.0f;
fGamePct = FMath::RoundToFloat(fGamePct);
Params.Add( TEXT( "CompletionPercent" ), FVariantData( (float)fGamePct ) );
if (UniqueID.IsValid())
{
Events->TriggerEvent(*UniqueID, TEXT("GameProgress"), Params);
}
}
}
}
}
}
}
