키즈멧 온라인 서브시스템

/**
 * 이 시퀸스 액션이 로컬 유저 번호가 붙어 뭔가 해야 하면 호출됩니다.
 */
protected function InternalOnActivated()
{
  local OnlineSubsystem OnlineSubsystem;

  // 온라인 서브시스템에 접속하여 업적 델리게이트를 링크합니다.
  OnlineSubsystem = class'GameEngine'.static.GetOnlineSubsystem();
  if (OnlineSubsystem != None && OnlineSubsystem.PlayerInterface != None)
  {
// ==========
// SteamWorks
// ==========
`if(`isdefined(USE_STEAMWORKS))
    // 업적 풀기를 시작합니다.
    BeginUnlockAchievement();

// ==========
// GameCenter
// ==========
`else
    // 게임 센터에서는 업적 리스트를 먼저 읽은 다음 풀어줘야 합니다.
    // 업적 읽기 델리게이트를 할당합니다.
    OnlineSubsystem.PlayerInterface.AddReadAchievementsCompleteDelegate(ProcessingPlayers[0].LocalUserNum, InternalOnReadAchievementsComplete);

    // 모든 업적을 읽습니다.
    OnlineSubsystem.PlayerInterface.ReadAchievements(ProcessingPlayers[0].LocalUserNum);
`endif
  }
}

/**
 * GameKismetSceneClient 는 게임 세션이 언제 끝나는지 감시하는 인터랙션입니다.
 * OnlineSubsystems 에 바인딩된 키즈멧 노드를 전부 청소하는 데 필요합니다.
 *
 * Copyright 1998-2012 Epic Games, Inc. All Rights Reserved.
 */
class GameKismetSceneClient extends Interaction;

/**
 * 현재 게임 세션이 끝나면 호출됩니다. 모든 OnlineSubsystemBase 키즈멧 노드를 청소합니다.
 */
function NotifyGameSessionEnded()
{
  local Sequence GameSequence;
  local array<SequenceObject> SequenceObjects;
  local SeqAct_OnlineSubsystemBase SeqAct_OnlineSubsystemBase;
  local int i;
  local WorldInfo WorldInfo;

  // 월드 인포를 구합니다.
  WorldInfo = class'WorldInfo'.static.GetWorldInfo();
  if (WorldInfo == None)
  {
    return;
  }

  // OnlineSubsystemBase 키즈멧 노드를 모두 청소합니다.
  GameSequence = WorldInfo.GetGameSequence();
  if (GameSequence != None)
  {
    GameSequence.FindSeqObjectsByClass(class'SeqAct_OnlineSubsystemBase', true, SequenceObjects);
    if (SequenceObjects.Length > 0)
    {
      for (i = 0; i < SequenceObjects.Length; ++i)
      {
        SeqAct_OnlineSubsystemBase = SeqAct_OnlineSubsystemBase(SequenceObjects[i]);
        if (SeqAct_OnlineSubsystemBase != None)
        {
          SeqAct_OnlineSubsystemBase.CleanUp(true);
        }
      }
    }
  }
}

defaultproperties
{
}

/**
 * OnlineSubsystemBase 액션은 로컬 사용자 번호를 요하는 다른 온라인 서브시스템 함수를 호출하는 데 사용되는 추상 액션입니다.
 *
 * Copyright 1998-2012 Epic Games, Inc. All Rights Reserved.
 */
class SeqAct_OnlineSubsystemBase extends SequenceAction
  abstract
  HideDropDown;

struct SProcessingPlayer
{
  var byte LocalUserNum;
  var UniqueNetId LocalNetId;
};

var private bool IsProcessing;
var protected array<SProcessingPlayer> ProcessingPlayers;
var protected bool HasCreatedSceneClient;

/**
 * 이 이벤트가 활성화되면 호출됩니다.
 */
event Activated()
{
  local SeqVar_Player SeqVar_Player;
  local bool AllPlayers;
  local array<int> PlayerIndices, ExistingPlayerIndices;
  local WorldInfo WorldInfo;
  local PlayerController PlayerController;
  local LocalPlayer LocalPlayer;
  local int i;
  local SProcessingPlayer ProcessingPlayer;
  local OnlineSubSystem OnlineSubSystem;
  local Sequence GameSequence;
  local array<SequenceObject> SequenceObjects;
  local SeqAct_OnlineSubsystemBase SeqAct_OnlineSubsystemBase;

  // 가비지 콜렉션 이벤트를 감시할 GameKismetSceneClient 를 삽입해야하는지 검사합니다.
  if (!HasCreatedSceneClient)
  {
    // 게임 키즈멧 씬 클라이언트를 삽입합니다.
    WorldInfo = GetWorldInfo();
    if (WorldInfo != None)
    {
      // 로컬 플레이어 콘트롤러를 구합니다.
      PlayerController = WorldInfo.GetALocalPlayerController();
      if (PlayerController != None)
      {
        LocalPlayer = LocalPlayer(PlayerController.Player);
        if (LocalPlayer != None && LocalPlayer.ViewportClient != None)
        {
          LocalPlayer.ViewportClient.InsertInteraction(new (LocalPlayer.ViewportClient) class'GameKismetSceneClient');
        }
      }
    }

    // 게임 키즈멧 씬 클라이언트가 생성된 SeqAct_OnlineSubsystemBase 를 전부 표시합니다.
    GameSequence = WorldInfo.GetGameSequence();
    if (GameSequence != None)
    {
      GameSequence.FindSeqObjectsByClass(class'SeqAct_OnlineSubsystemBase', true, SequenceObjects);
      if (SequenceObjects.Length > 0)
      {
        for (i = 0; i < SequenceObjects.Length; ++i)
        {
          SeqAct_OnlineSubsystemBase = SeqAct_OnlineSubsystemBase(SequenceObjects[i]);
          if (SeqAct_OnlineSubsystemBase != None)
          {
            SeqAct_OnlineSubsystemBase.NotifyGameKismetSceneClientCreated();
          }
        }
      }
    }
  }

  if (IsProcessing)
  {
    // Busy 출력을 활성화시킵니다.
    ActivateOutputLink(1);
    return;
  }

  // 온라인 서브시스템을 구합니다.
  OnlineSubSystem = class'GameEngine'.static.GetOnlineSubSystem();
  if (OnlineSubSystem == None || OnlineSubSystem.PlayerInterface == None)
  {
    return;
  }

  // 플레이어 인덱스를 구합니다.
  ForEach LinkedVariables(class'SeqVar_Player', SeqVar_Player)
  {
    if (SeqVar_Player.bAllPlayers)
    {
      AllPlayers = true;
      break;
    }
    else
    {
      PlayerIndices.AddItem(SeqVar_Player.PlayerIdx);
    }
  }

  // 처리가 필요한 플레이어를 찾습니다.
  WorldInfo = GetWorldInfo();
  if (WorldInfo != None)
  {
    // 모든 플레이어에게 참이면, 모든 플레이어를 대상으로 반복처리합니다.
    if (AllPlayers)
    {
      ForEach WorldInfo.AllControllers(class'PlayerController', PlayerController)
      {
        LocalPlayer = LocalPlayer(PlayerController.Player);
        if (LocalPlayer != None)
        {
          // 처리중인 플레이어 구조체를 만듭니다.
          ProcessingPlayer.LocalUserNum = class'UIInteraction'.static.GetPlayerIndex(LocalPlayer.ControllerId);
          OnlineSubSystem.PlayerInterface.GetUniquePlayerId(ProcessingPlayer.LocalUserNum, ProcessingPlayer.LocalNetId);

          // 처리중인 플레이어 구조체를 처리중인 플레이어 배열에 덧붙입니다.
          ProcessingPlayers.AddItem(ProcessingPlayer);
        }
      }
    }
    // 거짓이면 각 플레이어 인덱스에 대해 반복처리합니다.
    else if (PlayerIndices.Length > 0)
    {
      // 기존 플레이어 인덱스부터 전부 구합니다.
      ForEach WorldInfo.AllControllers(class'PlayerController', PlayerController)
      {
        LocalPlayer = LocalPlayer(PlayerController.Player);
        if (LocalPlayer != None)
        {
          ExistingPlayerIndices.AddItem(class'UIInteraction'.static.GetPlayerIndex(LocalPlayer.ControllerId));
        }
      }

      for (i = 0; i < PlayerIndices.Length; ++i)
      {
        if (ExistingPlayerIndices.Find(PlayerIndices[i]) != INDEX_NONE)
        {
          // 처리중인 플레이어 구조체를 만듭니다.
          ProcessingPlayer.LocalUserNum = PlayerIndices[i];
          OnlineSubSystem.PlayerInterface.GetUniquePlayerId(ProcessingPlayer.LocalUserNum, ProcessingPlayer.LocalNetId);

          // 처리중인 플레이어 구조체를 처리중인 플레이어 배열에 덧붙입니다.
          ProcessingPlayers.AddItem(ProcessingPlayer);
        }
      }
    }

    // 플레이어 1 을 처리합니다.
    if (ProcessingPlayers.Length > 0)
    {
      // 처리중 상태를 참으로 설정합니다.
      IsProcessing = true;

      // 활성화시킵니다.
      InternalOnActivated();
    }
  }

  // Out 출력을 활성화시킵니다.
  ActivateOutputLink(0);
}

/**
 * 키즈멧 노드가 이 플레이어에 대한 처리를 마치면 호출됩니다.
 *
 * @param      bWasSuccessful        참이면 키즈멧 노드가 작업에 성공한 것입니다.
 * @param      bProcessedAllPlayers    참이면 이 키즈멧 노드는 플레이어를 하나씩 처리한 것이 아니라 한 번에 모든 플레이어를 처리한 것입니다.
 */
protected function FinishedProcessPlayerIndex(bool bWasSuccessful, optional bool bProcessedAllPlayers)
{
  // 이 키즈멧 노드를 청소합니다.
  CleanUp();

  // 첫 번째 처리중인 플레이어 인덱스를 뽑아냅니다.
  if (ProcessingPlayers.Length > 0)
  {
    // 모든 플레이어를 처리했다면, 이제 그 모두를 제거합니다.
    if (bProcessedAllPlayers)
    {
      ProcessingPlayers.Remove(0, ProcessingPlayers.Length);
    }
    // 아니라면 하나만 처리한 것이니, 맨위에서 뽑아냅니다.
    else
    {
      ProcessingPlayers.Remove(0, 1);
    }
  }

  // 처리할 플레이어 인덱스가 남아있는 경우, 다음 것을 처리합니다.
  if (ProcessingPlayers.Length > 0)
  {
    InternalOnActivated();
  }
  // 남아있지 않으면, 이 키즈멧 노드는 처리가 끝났으며 출력중 하나를 활성화시켜야 합니다.
  else
  {
    IsProcessing = false;
    ForceActivateOutput((bWasSuccessful) ? 2 : 3);
  }
}

/**
 * 이 시퀸스 액션이 로컬 유저 숫자를 붙여 어떤 작업을 해야할 때 호출됩니다.
 */
protected function InternalOnActivated();

/**
 * 가비지 콜렉션이 일어날 수 있도록 이 키즈멧 노드가 모든 변수나 델리게이트 리퍼런스를 청소해야 할 때 호출됩니다.
 *
 * @param    IsExiting      빠져나가는 중이라면 모든 것을 청소합니다.
 */
function CleanUp(optional bool IsExiting)
{
  // 처리중인 플레이어 배열을 비웁니다.
  if (IsExiting)
  {
    ProcessingPlayers.Remove(0, ProcessingPlayers.Length);
  }
}

/**
 * 게임 세션이 언제 끝났는지, 게임을 언제 청소해야할 지 잡아내는 데 사용되는 GameKismetSceneClient 를, 키즈멧 노드가 만들었을 때 호출됩니다.
 */
function NotifyGameKismetSceneClientCreated()
{
  HasCreatedSceneClient = true;
}

defaultproperties
{
`if(`isdefined(USE_STEAMWORKS))
  ObjCategory="Steamworks"
`elseif(`isdefined(USE_GAMECENTER))
  ObjCategory="Game Center"
`endif
  ObjColor=(R=0,G=63,B=127,A=255)

  bAutoActivateOutputLinks=false

  VariableLinks.Empty
  VariableLinks(0)=(ExpectedType=class'SeqVar_Player',LinkDesc="Player")

  OutputLinks(1)=(LinkDesc="Busy")
  OutputLinks(2)=(LinkDesc="Succeeded")
  OutputLinks(3)=(LinkDesc="Failed")
}

/**
 * 업적을 푸는 데는 UnlockAchievement 액션이 사용됩니다.
 *
 * Copyright 1998-2012 Epic Games, Inc. All Rights Reserved.
 */
class SeqAct_UnlockAchievement extends SeqAct_OnlineSubsystemBase;

// 풀고자 하는 업적 ID 입니다.
var() int AchievementId;

// ==========
// GameCenter
// ==========
`if(`isdefined(USE_GAMECENTER))
// 참이면 업적이 이미 풀린 것으로, 여전히 성공 링크는 출력합니다.
var() bool AlwaysUnlockAchievement;
// 모든 다운로드 업적 배열
var protected array<AchievementDetails> DownloadedAchievements;
`endif

/**
 * 이 시퀸스 액션이 로컬 유저 번호를 붙여 어떤 작업을 해야 하면 호출됩니다.
 */
protected function InternalOnActivated()
{
  local OnlineSubsystem OnlineSubsystem;

  // 온라인 서브시스템에 접속하여 업적 델리게이트를 링크합니다.
  OnlineSubsystem = class'GameEngine'.static.GetOnlineSubsystem();
  if (OnlineSubsystem != None && OnlineSubsystem.PlayerInterface != None)
  {
// ==========
// SteamWorks
// ==========
`if(`isdefined(USE_STEAMWORKS))
    // 업적 풀기를 시작합니다.
    BeginUnlockAchievement();

// ==========
// GameCenter
// ==========
`else
    // Game Center 에서는 업적 리스트를 먼저 읽은 다음 업적을 풀어야 합니다.
    // 업적 읽기 델리게이트를 할당합니다.
    OnlineSubsystem.PlayerInterface.AddReadAchievementsCompleteDelegate(ProcessingPlayers[0].LocalUserNum, InternalOnReadAchievementsComplete);

    // 모든 업적을 읽습니다.
    OnlineSubsystem.PlayerInterface.ReadAchievements(ProcessingPlayers[0].LocalUserNum);
`endif
  }
}

// ==========
// GameCenter
// ==========
`if(`isdefined(USE_GAMECENTER))
/**
 * 비동기 업적 읽기가 끝나면 호출됩니다.
 *
 * @param    TitleId      읽기 대상이었던 타이틀 ID 입니다. (0 은 현재 타이틀)
 */
protected function InternalOnReadAchievementsComplete(int TitleId)
{
  local OnlineSubsystem OnlineSubsystem;
  local int AchievementIndex;

  // 온라인 서브시스템이 있는지, 연결된 플레이어 인터페이스는 있는지 확인합니다.
  OnlineSubsystem = class'GameEngine'.static.GetOnlineSubsystem();
  if (OnlineSubsystem == None || OnlineSubsystem.PlayerInterface == None)
  {
    return;
  }

  // 업적을 다운로드 업적 배열에 읽어들입니다.
  OnlineSubsystem.PlayerInterface.GetAchievements(ProcessingPlayers[0].LocalUserNum, DownloadedAchievements, TitleId);

  // 업적 인덱스를 구해옵니다.
  AchievementIndex = DownloadedAchievements.Find('Id', AchievementId);

  // 업적을 풉니다.
  if (AchievementIndex != INDEX_NONE)
  {
    // 아직 풀지 않았으니, 풀기 프로세스를 시작합니다.
    if (!DownloadedAchievements[AchievementIndex].bWasAchievedOnline)
    {
      BeginUnlockAchievement();
    }
    // 이미 풀었으니 끝냅니다.
    else if (AlwaysUnlockAchievement)
    {
      InternalOnUnlockAchievementComplete(true);
    }
  }
}
`endif

/**
 * 업적 풀기를 시작해야 하면 호출됩니다.
 *
 * @param    AchievementId      풀 업적입니다.
 * @param    LocalUserNum      로컬 유저 인덱스입니다.
 */
protected function BeginUnlockAchievement()
{
  local OnlineSubsystem OnlineSubsystem;

  // 온라인 서브시스템을 구합니다.
  OnlineSubsystem = class'GameEngine'.static.GetOnlineSubsystem();
  if (OnlineSubsystem == None || OnlineSubsystem.PlayerInterface == None)
  {
    return;
  }

  // 업적 풀기 완료 델리게이트를 할당합니다.
  OnlineSubsystem.PlayerInterface.AddUnlockAchievementCompleteDelegate(ProcessingPlayers[0].LocalUserNum, InternalOnUnlockAchievementComplete);

  // 풀기 프로세스를 시작합니다.
  OnlineSubsystem.PlayerInterface.UnlockAchievement(ProcessingPlayers[0].LocalUserNum, AchievementId);
}

/**
 * 업적 풀기가 끝나면 호출됩니다.
 *
 * @param     bWasSuccessful      참이면 비동기 작업이 에러 없이 끝난 것이며, 거짓이면 에러가 생긴 것입니다.
 */
protected function InternalOnUnlockAchievementComplete(bool bWasSuccessful)
{
  // 이 업적 풀기가 끝났습니다.
  FinishedProcessPlayerIndex(bWasSuccessful);
}

/**
 * 가비지 콜렉션이 일어날 수 있도록 이 키즈멧 노드가 모든 변수나 델리게이트 리퍼런스를 모두 청소해야 할 때 호출됩니다.
 *
 * @param    IsExiting      빠져나가는 중이라면 모든 것을 청소합니다.
 */
function CleanUp(optional bool IsExiting)
{
  local OnlineSubsystem OnlineSubsystem;
  local int i, InPlayerIndex;

  // 온라인 서브시스템을 구한 다음 모든 델리게이트 바인딩을 제거합니다.
  OnlineSubsystem = class'GameEngine'.static.GetOnlineSubsystem();
  if (OnlineSubsystem != None && OnlineSubsystem.PlayerInterface != None)
  {
    // 분할 화면 로컬 플레이어 최대 수는 4 입니다.
    for (i = 0; i < 4; ++i)
    {
      // 플레이어 인덱스를 구합니다.
      InPlayerIndex = class'UIInteraction'.static.GetPlayerIndex(i);
      if (InPlayerIndex >= 0)
      {
      // 델리게이트를 지웁니다.
// ==========
// GameCenter
// ==========
`if(`isdefined(USE_GAMECENTER))
        OnlineSubsystem.PlayerInterface.ClearReadAchievementsCompleteDelegate(InPlayerIndex, InternalOnReadAchievementsComplete);
`endif
        OnlineSubsystem.PlayerInterface.ClearUnlockAchievementCompleteDelegate(InPlayerIndex, InternalOnUnlockAchievementComplete);
      }
    }
  }

  // 그냥 빠져나가려는 경우엔 super 를 호출합니다.
  Super.CleanUp(IsExiting);
}

defaultproperties
{
// ==========
// GameCenter
// ==========
`if(`isdefined(USE_GAMECENTER))
  AlwaysUnlockAchievement=true
`endif
  ObjName="Unlock Achievement"
  VariableLinks(1)=(ExpectedType=class'SeqVar_Int',LinkDesc="Achievement Id",PropertyName=AchievementId)
}

/**
 * Modify Online Stat 액션은 통계를 수정하고 업로드하는 데 사용됩니다.
 *
 * Copyright 1998-2012 Epic Games, Inc. All Rights Reserved.
 */
class SeqAct_ModifyOnlineStat extends SeqAct_OnlineSubsystemBase;

// 통계 기반 구조체입니다.
struct SStat
{
  var() Name LinkedVariableName;
  var() int StatId;
};

// 정수 기반 통계입니다.
struct SIntStat extends SStat
{
  var() int Value;
};

// 실수 기반 통계입니다.
struct SFloatStat extends SStat
{
  var() float Value;
};

// 사용자가 원하는 통계 수정 메서드입니다.
enum EModifyMethod
{
  MM_Set<DisplayName=Set>,
// ==========
// Steamworks
// ==========
`if(`isdefined(USE_STEAMWORKS))
  MM_Add<DisplayName=Add>,
  MM_Subtract<DisplayName=Subtract>,
`endif
};

// 통계와 연결된 온라인 통계 쓰기 클래스입니다.
var() class<OnlineStatsWrite> OnlineStatsWriteClass;
// ==========
// Steamworks
// ==========
`if(`isdefined(USE_STEAMWORKS))
// 통계와 연결된 온라인 통계 읽기 클래스입니다.
var() class<OnlineStatsRead> OnlineStatsReadClass;
`endif
// 정수 기반 통계 배열입니다.
var() array<SIntStat> IntStats;
// 실수 기반 통계 배열입니다.
var() array<SFloatStat> FloatStats;
// 통계 수정 메서드입니다.
var() EModifyMethod ModifyMethod;
// 세션 이름입니다.
var() Name SessionName;

// 온라인 통계 쓰기 오브젝트 인스턴스입니다.
var protected OnlineStatsWrite OnlineStatsWrite;
// 온라인 통계 읽기 오브젝트 인스턴스입니다.
var protected OnlineStatsRead OnlineStatsRead;

/**
 *  이 시퀸스 액션이 로컬 유저 번호를 붙여 어떤 작업을 해야 할 때 호출됩니다.
 */
protected function InternalOnActivated()
{
  // 온라인 통계 쓰기 클래스가 없으면 중단합니다.
  // 열 ID 가 없으면 중단합니다.
  if (OnlineStatsWriteClass == None || IntStats.Length <= 0)
  {
    return;
  }

// ==========
// Steamworks
// ==========
`if(`isdefined(USE_STEAMWORKS))
  // 사용자가 더하기나 빼기를 사용하여 통계를 수정하려 합니다.
  if (ModifyMethod == MM_Add || ModifyMethod == MM_Subtract)
  {
    ReadOnlineStats();
  }
  // 사용자가 값을 설정하여 통계를 수정하려 합니다.
  else
  {
`endif
    SetStatValue();
// ==========
// Steamworks
// ==========
`if(`isdefined(USE_STEAMWORKS))
  }
`endif
}

// ==========
// Steamworks
// ==========
`if(`isdefined(USE_STEAMWORKS))
/**
 * 사용자가 증가나 감소를 사용하여 통계를 수정하려 할 때 호출됩니다.
 */
protected function ReadOnlineStats()
{
  local OnlineSubsystem OnlineSubsystem;
  local array<UniqueNetId> PlayerIds;

  // 온라인 통계 읽기를 시도합니다.
  OnlineSubsystem = class'GameEngine'.static.GetOnlineSubsystem();
  if (OnlineSubsystem != None && OnlineSubsystem.StatsInterface != None)
  {
    OnlineSubsystem.StatsInterface.AddReadOnlineStatsCompleteDelegate(InternalOnReadOnlineStatsComplete);

    PlayerIds.AddItem(ProcessingPlayers[0].LocalNetId);
    OnlineStatsRead = new () OnlineStatsReadClass;
    if (OnlineStatsRead != None)
    {
      OnlineSubsystem.StatsInterface.ReadOnlineStats(PlayerIds, OnlineStatsRead);
    }
  }
}

/**
 * 온라인 통계 읽기가 끝나면 호출됩니다.
 *
 * @param    bWasSuccessful      참이면 온라인 통계 읽기가 성공한 것입니다.
 */
function InternalOnReadOnlineStatsComplete(bool bWasSuccessful)
{
  local OnlineSubsystem OnlineSubsystem;
  local int i, ReadIntStatValue;
  local float ReadFloatStatValue;
  local SeqVar_Int SeqVar_Int;
  local SeqVar_Float SeqVar_Float;

  // 통계 읽기에 성공했다면
  if (bWasSuccessful && OnlineStatsRead != None)
  {
    // 통계를 쓰고
    OnlineSubsystem = class'GameEngine'.static.GetOnlineSubsystem();
    if (OnlineSubsystem != None && OnlineSubsystem.StatsInterface != None)
    {
      // 통계 쓰기 오브젝트 인스턴스를 만듭니다.
      OnlineStatsWrite = new () OnlineStatsWriteClass;
      if (OnlineStatsWrite != None)
      {
        // 정수 통계 쓰기 값을 수정합니다.
        for (i = 0; i < IntStats.Length; ++i)
        {
          OnlineStatsRead.GetIntStatValueForPlayer(ProcessingPlayers[0].LocalNetId, IntStats[i].StatId, ReadIntStatValue);

          // 이 스테이트에 변수명이 있으면, 찾아봅니다.
          if (IntStats[i].LinkedVariableName != '' && IntStats[i].LinkedVariableName != 'None')
          {
            ForEach LinkedVariables(class'SeqVar_Int', SeqVar_Int)
            {
              if (SeqVar_Int.VarName == IntStats[i].LinkedVariableName)
              {
                switch (ModifyMethod)
                {
                case MM_Add:
                  OnlineStatsWrite.SetIntStat(IntStats[i].StatId, ReadIntStatValue + SeqVar_Int.IntValue);
                  break;

                case MM_Subtract:
                  OnlineStatsWrite.SetIntStat(IntStats[i].StatId, ReadIntStatValue - SeqVar_Int.IntValue);
                  break;

                default:
                  break;
                }
              }
            }
          }
          // 없으면, 구조체에 정의된 값을 사용합니다.
          else
          {
            switch (ModifyMethod)
            {
            case MM_Add:
              OnlineStatsWrite.SetIntStat(IntStats[i].StatId, ReadIntStatValue + IntStats[i].Value);
              break;

            case MM_Subtract:
              OnlineStatsWrite.SetIntStat(IntStats[i].StatId, ReadIntStatValue - IntStats[i].Value);
              break;

            default:
              break;
            }
          }
        }

        // 실수 통계 쓰기 값을 수정합니다.
        for (i = 0; i < FloatStats.Length; ++i)
        {
          OnlineStatsRead.GetFloatStatValueForPlayer(ProcessingPlayers[0].LocalNetId, FloatStats[i].StatId, ReadFloatStatValue);

          // 이 스테이트에 변수명이 있다면, 찾아봅니다.
          if (FloatStats[i].LinkedVariableName != '' && FloatStats[i].LinkedVariableName != 'None')
          {
            ForEach LinkedVariables(class'SeqVar_Float', SeqVar_Float)
            {
              if (SeqVar_Float.VarName == FloatStats[i].LinkedVariableName)
              {
                switch (ModifyMethod)
                {
                case MM_Add:
                  OnlineStatsWrite.SetFloatStat(FloatStats[i].StatId, ReadFloatStatValue + SeqVar_Float.FloatValue);
                  break;

                case MM_Subtract:
                  OnlineStatsWrite.SetFloatStat(FloatStats[i].StatId, ReadFloatStatValue - SeqVar_Float.FloatValue);
                  break;

                default:
                  break;
                }
              }
            }
          }
          // 없다면, 구조체에 정의된 값을 사용합니다.
          else
          {
            switch (ModifyMethod)
            {
            case MM_Add:
              OnlineStatsWrite.SetFloatStat(FloatStats[i].StatId, ReadFloatStatValue + FloatStats[i].Value);
              break;

            case MM_Subtract:
              OnlineStatsWrite.SetFloatStat(FloatStats[i].StatId, ReadFloatStatValue - FloatStats[i].Value);
              break;

            default:
              break;
            }
          }
        }

        // 통계 핸들러에 쓰기 요청을 보냅니다.
        if (OnlineSubsystem.StatsInterface.WriteOnlineStats(SessionName, ProcessingPlayers[0].LocalNetId, OnlineStatsWrite))
        {
          // flush 델리게이트를 추가합니다.
          OnlineSubsystem.StatsInterface.AddFlushOnlineStatsCompleteDelegate(InternalOnFlushOnlineStatsComplete);
          // 온라인 통계를 flush 합니다.
          OnlineSubsystem.StatsInterface.FlushOnlineStats(SessionName);
        }
        // Failed 출력 링크를 활성화시킵니다.
        else
        {
          ForceActivateOutput(3);
        }
      }
    }
  }
  else
  {
    FinishedProcessPlayerIndex(bWasSuccessful);
  }
}
`endif

/**
 * 이 키즈멧 노드가 통계 값을 직접 설정할 때 호출됩니다.
 */
protected function SetStatValue()
{
  local OnlineSubsystem OnlineSubsystem;
  local int i;
  local SeqVar_Int SeqVar_Int;
  local SeqVar_Float SeqVar_Float;

  // 통계를 씁니다.
  OnlineSubsystem = class'GameEngine'.static.GetOnlineSubsystem();
  if (OnlineSubsystem != None && OnlineSubsystem.StatsInterface != None)
  {
    // 통계 쓰기 오브젝트의 인스턴스를 만듭니다.
    OnlineStatsWrite = new () OnlineStatsWriteClass;
    if (OnlineStatsWrite != None)
    {
      // 정수 통계 쓰기 값을 설정합니다.
      for (i = 0; i < IntStats.Length; ++i)
      {
        // 이 스테이트에 변수명이 있다면, 찾아봅니다.
        if (IntStats[i].LinkedVariableName != '' && IntStats[i].LinkedVariableName != 'None')
        {
          ForEach LinkedVariables(class'SeqVar_Int', SeqVar_Int)
          {
            if (SeqVar_Int.VarName == IntStats[i].LinkedVariableName)
            {
              OnlineStatsWrite.SetIntStat(IntStats[i].StatId, SeqVar_Int.IntValue);
              break;
            }
          }
        }
        // 없다면, 구조체에 정의된 값을 사용합니다.
        else
        {
          OnlineStatsWrite.SetIntStat(IntStats[i].StatId, IntStats[i].Value);
          break;
        }
      }

      // 실수 통계 쓰기 값을 수정합니다.
      for (i = 0; i < FloatStats.Length; ++i)
      {
        // 이 스테이트에 변수명이 있다면, 찾아봅니다.
        if (FloatStats[i].LinkedVariableName != '' && FloatStats[i].LinkedVariableName != 'None')
        {
          ForEach LinkedVariables(class'SeqVar_Float', SeqVar_Float)
          {
            if (SeqVar_Float.VarName == FloatStats[i].LinkedVariableName)
            {
              OnlineStatsWrite.SetFloatStat(FloatStats[i].StatId, SeqVar_Float.FloatValue);
            }
          }
        }
        // 없다면, 구조체에 정의된 값을 사용합니다.
        else
        {
          OnlineStatsWrite.SetFloatStat(FloatStats[i].StatId, FloatStats[i].Value);
        }
      }

      // 통계 핸들러에 쓰기 요청을 보냅니다.
      if (OnlineSubsystem.StatsInterface.WriteOnlineStats(SessionName, ProcessingPlayers[0].LocalNetId, OnlineStatsWrite))
      {
// ==========
// SteamWorks
// ==========
`if(`isdefined(USE_STEAMWORKS))
        // flush 델리게이트를 추가합니다.
        OnlineSubsystem.StatsInterface.AddFlushOnlineStatsCompleteDelegate(InternalOnFlushOnlineStatsComplete);
`endif
        // 온라인 통계를 flush 합니다.
        OnlineSubsystem.StatsInterface.FlushOnlineStats(SessionName);
// ==========
// GameCenter
// ==========
`if(`isdefined(USE_GAMECENTER))
        // 모든 오브젝트 레퍼런스를 비웁니다.
        OnlineStatsWrite = None;
        OnlineStatsRead = None;

        // 플레이어 인덱스 처리를 핸들링합니다.
        FinishedProcessPlayerIndex(true);
`endif
      }
      // Failed 출력 링크를 활성화시킵니다.
      else
      {
        ForceActivateOutput(3);
      }
    }
  }
}

`if(`isdefined(USE_STEAMWORKS))
/**
 * 통계 플러시 작업이 완료되었을 때 호출됩니다.
 *
 * @param SessionName 플러시 대상 통계를 가진 세션 이름입니다.
 * @param bWasSuccessful 참이면 비동기 작업이 에러 없이 끝난 것이고, 거짓이면 에러가 생긴 것입니다.
 */
function InternalOnFlushOnlineStatsComplete(Name InSessionName, bool bWasSuccessful)
{
  // 모든 오브젝트 리퍼런스를 비웁니다.
  OnlineStatsWrite = None;
  OnlineStatsRead = None;

  // 플레이어 인덱스 처리를 핸들링합니다.
  FinishedProcessPlayerIndex(bWasSuccessful);
}
`endif

/**
 * 가비지 콜렉션이 일어날 수 있도록 이 키즈멧 노드가 모든 변수나 델리게이트 리퍼런스를 청소해야 할 때 호출됩니다.
 *
 * @param    IsExiting      빠져나가는 중이면 모든 것을 청소합니다.
 */
function CleanUp(optional bool IsExiting)
{
// ==========
// SteamWorks
// ==========
`if(`isdefined(USE_STEAMWORKS))
  local OnlineSubsystem OnlineSubsystem;
  local int i, InPlayerIndex;

  // 온라인 서브시스템을 구하고 모든 델리게이트 바인딩을 제거합니다.
  OnlineSubsystem = class'GameEngine'.static.GetOnlineSubsystem();
  if (OnlineSubsystem != None && OnlineSubsystem.StatsInterface != None)
  {
    // 분할 화면 로컬 플레이어 최대 수는 4 입니다.
    for (i = 0; i < 4; ++i)
    {
      // 플레이어 인덱스를 구합니다.
      InPlayerIndex = class'UIInteraction'.static.GetPlayerIndex(i);
      if (InPlayerIndex >= 0)
      {
        // 델리게이트를 비웁니다.
        OnlineSubsystem.StatsInterface.ClearFlushOnlineStatsCompleteDelegate(InternalOnFlushOnlineStatsComplete);
        OnlineSubsystem.StatsInterface.ClearReadOnlineStatsCompleteDelegate(InternalOnReadOnlineStatsComplete);
      }
    }
  }
`endif

  // 온라인 통계 쓰기 오브젝트를 비웁니다.
  OnlineStatsWrite = None;
  // 온라인 통계 읽기 오브젝트를 비웁니다.
  OnlineStatsRead = None;

  // 딱 빠져나가는 경우라면 super 를 호출합니다.
  Super.CleanUp(IsExiting);
}

defaultproperties
{
  SessionName="Game"
  ObjName="Modify Online Stat"

  VariableLinks(1)=(ExpectedType=class'SeqVar_Int',LinkDesc="Stat Values")
}

/**
 * Refresh Achievements 액션은 모든 업적을 새로고치는 데 사용됩니다.
 *
 * Copyright 1998-2012 Epic Games, Inc. All Rights Reserved.
 */
class SeqAct_RefreshAchievements extends SeqAct_OnlineSubsystemBase
`if(`notdefined(USE_STEAMWORKS))
  abstract
  HideDropDown;
`else
  ;

/**
 * 이 시퀸스 액션이 로컬 유저 번호를 붙여 어떤 작업을 해야 할 때 호출됩니다.
 */
protected function InternalOnActivated()
{
  local OnlineSubSystem OnlineSubSystem;

  OnlineSubSystem = class'GameEngine'.static.GetOnlineSubSystem();
  if (OnlineSubSystem != None && OnlineSubSystem.PlayerInterface != None)
  {
    // 델리게이트를 바인딩합니다.
    OnlineSubSystem.PlayerInterface.AddReadAchievementsCompleteDelegate(ProcessingPlayers[0].LocalUserNum, InternalOnReadAchievementsComplete);

    // 모든 업적을 읽습니다.
    OnlineSubsystem.PlayerInterface.ReadAchievements(ProcessingPlayers[0].LocalUserNum);
  }
}

/**
 * 비동기 업적 읽기가 끝나면 호출됩니다.
 *
 * @param TitleId 읽기 대상이었던 타이틀 ID 입니다. (0 은 현재 타이틀)
 */
function InternalOnReadAchievementsComplete(int TitleId)
{
  FinishedProcessPlayerIndex(true);
}

/**
 * 가비지 콜렉션이 일어날 수 있도록 이 키즈멧 노드가 모든 변수나 델리게이트 리퍼런스를 청소해야 하면 호출됩니다.
 *
 * @param    IsExiting      빠져나가는 중이라면 모든 것을 청소합니다.
 */
function CleanUp(optional bool IsExiting)
{
  local OnlineSubsystem OnlineSubsystem;
  local int i, InPlayerIndex;

  // 온라인 서브시스템을 구하고 모든 델리게이트 바인딩을 지웁니다.
  OnlineSubsystem = class'GameEngine'.static.GetOnlineSubsystem();
  if (OnlineSubsystem != None && OnlineSubsystem.PlayerInterface != None)
  {
    // 분할 화면 로컬 플레이어 최대치는 4 입니다.
    for (i = 0; i < 4; ++i)
    {
      // 플레이어 인덱스를 구합니다.
      InPlayerIndex = class'UIInteraction'.static.GetPlayerIndex(i);
      if (InPlayerIndex >= 0)
      {
        // 델리게이트를 비웁니다.
        OnlineSubsystem.PlayerInterface.ClearReadAchievementsCompleteDelegate(InPlayerIndex, InternalOnReadAchievementsComplete);
      }
    }
  }

  // 딱 빠져나가는 경우라면 super 를 호출합니다.
  Super.CleanUp(IsExiting);
}
`endif

defaultproperties
{
  ObjName="Refresh Achievements"
}

/**
 * Reset Achievements 액션은 플레이어가 얻은 업적 전부를 리셋시키는 데 사용됩니다.
 *
 * Copyright 1998-2012 Epic Games, Inc. All Rights Reserved.
 */
class SeqAct_ResetAchievements extends SeqAct_OnlineSubsystemBase
`if(`notdefined(USE_STEAMWORKS))
  abstract
  HideDropDown;
`else
  ;

// 참이면 업적도 리셋됩니다. 거짓이면 통계만 리셋됩니다.
var() const bool ResetAchievements;

/**
 * 이 시퀸스 액션이 로컬 유저 번호를 붙여 어떤 작업을 해야 할 때 호출됩니다.
 */
protected function InternalOnActivated()
{
  local OnlineSubsystemSteamworks OnlineSubsystemSteamworks;
  local bool bWasSuccessful;

  OnlineSubsystemSteamworks = OnlineSubsystemSteamworks(class'GameEngine'.static.GetOnlineSubsystem());
  if (OnlineSubsystemSteamworks != None)
  {
    bWasSuccessful = OnlineSubsystemSteamworks.ResetStats(ResetAchievements);
  }
  else
  {
    bWasSuccessful = false;
  }

  FinishedProcessPlayerIndex(bWasSuccessful);
}
`endif

defaultproperties
{
`if(`isdefined(USE_STEAMWORKS))
  ResetAchievements=true
`endif
  ObjName="Reset Achievements/Stats"
}

/**
 * Read Online Stat 액션은 온라인 통계를 읽는 데 사용됩니다.
 *
 * Copyright 1998-2012 Epic Games, Inc. All Rights Reserved.
 */
class SeqAct_ReadOnlineStat extends SeqAct_OnlineSubsystemBase
// ==========
// GameCenter
// ==========
`if(`isdefined(USE_GAMECENTER))
  abstract
  HideDropdown;
`else
  ;
//
enum EReadStatsMethod
{
  RST_ReadAll<DisplayName=Read all stats>,
  RST_ReadFriendsOnly<DisplayName=Read stats of friends>,
  RST_ReadByRank<DisplayName=Read stats by rank>,
  RST_ReadByRankAroundPlayer<DisplayName=Read stats around player>
};

//
struct SLinkedVariableName
{
  var() int StatId;
  var() Name LinkedVariableName;
};

// 통계를 읽는 데 사용할 클래스입니다.
var() class<OnlineStatsRead> OnlineStatsReadClass;
// 통계 읽기 메서드입니다.
var() EReadStatsMethod ReadStatsMethod;
// 랭킹 통계 읽기 메서드를 사용하는 경우, 사용할 시작 랭크 인덱스 입니다.
var() int StartRankIndex;
// 랭킹 통계 읽기나 플레이어 근처 랭킹 메서드를 사용하는 경우에 몇 줄이나 읽을지 입니다.
var() int RowCount;
// 출력시킬 링크 변수 입니다.
var() array<SLinkedVariableName> LinkedVariableNames;

// 온라인 통계 읽기 오브젝트의 인스턴스를 만듭니다.
var protected OnlineStatsRead OnlineStatsRead;
// 키즈멧 변수에 매핑되는 랭크 변수입니다.
var int Rank;

/**
 * 이 시퀸스 액션이 로컬 유저 번호를 붙여 어떤 작업을 해야 할 때 호출됩니다.
 */
protected function InternalOnActivated()
{
  local OnlineSubSystem OnlineSubSystem;
  local array<UniqueNetId> PlayerIds;

  // 온라인 통계 읽기 클래스가 없으면 중단합니다.
  // 열 ID 가 없으면 중단합니다.
  if (OnlineStatsReadClass == None || LinkedVariableNames.Length <= 0)
  {
    return;
  }

  // 통계를 요청합니다.
  OnlineSubSystem = class'GameEngine'.static.GetOnlineSubSystem();
  if (OnlineSubSystem != None && OnlineSubSystem.StatsInterface != None)
  {
    // 온라인 통계 인스턴스를 만듭니다.
    OnlineStatsRead = new () OnlineStatsReadClass;
    if (OnlineStatsRead != None)
    {
      // 통계를 해제합니다.
      OnlineSubsystem.StatsInterface.FreeStats(OnlineStatsRead);

      // 온라인 통계 읽기 델리게이트를 바인딩합니다.
      OnlineSubsystem.StatsInterface.AddReadOnlineStatsCompleteDelegate(InternalOnReadOnlineStatsComplete);

      switch (ReadStatsMethod)
      {
      // 친구 통계만 읽습니다.
      case RST_ReadFriendsOnly:
        OnlineSubsystem.StatsInterface.ReadOnlineStatsForFriends(ProcessingPlayers[0].LocalUserNum, OnlineStatsRead);
        break;

      // 랭킹별 통계만 읽습니다.
      case RST_ReadByRank:
        OnlineSubsystem.StatsInterface.ReadOnlineStatsByRank(OnlineStatsRead, StartRankIndex, RowCount);
        break;

      // 플레이어 주변 통계만 읽습니다.
      case RST_ReadByRankAroundPlayer:
        OnlineSubsystem.StatsInterface.ReadOnlineStatsByRankAroundPlayer(ProcessingPlayers[0].LocalUserNum, OnlineStatsRead, RowCount);
        break;

        // 모든 통계를 읽습니다.
      case RST_ReadAll:
      default:
        PlayerIds.AddItem(ProcessingPlayers[0].LocalNetId);
        OnlineSubsystem.StatsInterface.ReadOnlineStats(PlayerIds, OnlineStatsRead);
        break;
      }
    }
  }
}

/**
 * 관련된 파티에 지난 통계 읽기가 끝났음을 알립니다.
 *
 * @param bWasSuccessful 참이면 비동기 작업이 에러 없이 끝난 것이고, 거짓이면 에러가 생긴 것입니다.
 */
function InternalOnReadOnlineStatsComplete(bool bWasSuccessful)
{
  local int i;
  local SeqVar_Int SeqVar_Int;
  local SeqVar_Float SeqVar_Float;

  if (OnlineStatsRead != None)
  {
    // 처리중인 플레이어에 대한 통계 ID 를 출력합니다.
    if (LinkedVariableNames.Length > 0)
    {
      for (i = 0; i < LinkedVariableNames.Length; ++i)
      {
        if (LinkedVariableNames[i].LinkedVariableName != '' && LinkedVariableNames[i].LinkedVariableName != 'None')
        {
          // 정수 통계를 시퀸스 변수로 복사합니다.
          ForEach LinkedVariables(class'SeqVar_Int', SeqVar_Int)
          {
            if (SeqVar_Int.VarName == LinkedVariableNames[i].LinkedVariableName)
            {
              OnlineStatsRead.GetIntStatValueForPlayer(ProcessingPlayers[0].LocalNetId, LinkedVariableNames[i].StatId, SeqVar_Int.IntValue);
            }
          }

          // 실수 통계를 시퀸스 변수로 복사합니다.
          ForEach LinkedVariables(class'SeqVar_Float', SeqVar_Float)
          {
            if (SeqVar_Float.VarName == LinkedVariableNames[i].LinkedVariableName)
            {
              OnlineStatsRead.GetFloatStatValueForPlayer(ProcessingPlayers[0].LocalNetId, LinkedVariableNames[i].StatId, SeqVar_Float.FloatValue);
            }
          }
        }
      }
    }

    // 순위를 출력합니다.
    Rank = OnlineStatsRead.GetRankForPlayer(ProcessingPlayers[0].LocalNetId);
    // 링크 변수를 채웁니다.
    PopulateLinkedVariableValues();
  }

  // 플레이어 처리 완료입니다.
  FinishedProcessPlayerIndex(bWasSuccessful);
  // 온라인 통계 읽기로의 리퍼런스를 제거합니다.
  OnlineStatsRead = None;
}

/**
 * 가비지 콜렉션이 일어날 수 있도록 이 키즈멧 노드가 모든 변수나 델리게이트 리퍼런스를 청소해야 하면 호출됩니다.
 *
 * @param    IsExiting      빠져나가는 중이라면 모든 것을 청소합니다.
 */
function CleanUp(optional bool IsExiting)
{
  local OnlineSubsystem OnlineSubsystem;
  local int i, InPlayerIndex;

  // 온라인 서브시스템을 구하고 모든 델리게이트 바인딩을 지웁니다.
  OnlineSubsystem = class'GameEngine'.static.GetOnlineSubsystem();
  if (OnlineSubsystem != None && OnlineSubsystem.StatsInterface != None)
  {
    // 분할 화면 로컬 플레이어 최대치는 4 입니다.
    for (i = 0; i < 4; ++i)
    {
      // 플레이어 인덱스를 구합니다.
      InPlayerIndex = class'UIInteraction'.static.GetPlayerIndex(i);
      if (InPlayerIndex >= 0)
      {
        // 델리게이트를 비웁니다.
        OnlineSubsystem.StatsInterface.ClearReadOnlineStatsCompleteDelegate(InternalOnReadOnlineStatsComplete);
      }
    }
  }

  // 온라인 통계 읽기 오브젝트를 비웁니다.
  OnlineStatsRead = None;

  // 딱 빠져나가는 경우라면 super 를 호출합니다.
  Super.CleanUp(IsExiting);
}
`endif

defaultproperties
{
  ObjName="Read Online Stat"

// ==========
// SteamWorks
// ==========
`if(`isdefined(USE_STEAMWORKS))
  StartRankIndex=1
  RowCount=50
`endif

  VariableLinks(1)=(ExpectedType=class'SeqVar_Int',LinkDesc="Stat Values",bWriteable=true)
  VariableLinks(2)=(ExpectedType=class'SeqVar_Int',LinkDesc="Rank",bWriteable=true,PropertyName=Rank)
}

/**
 * Mobile Show Achievements UI 액션은 업적 UI 를 표시하는 데 사용됩니다.
 *
 * Copyright 1998-2012 Epic Games, Inc. All Rights Reserved.
 */
class SeqAct_Mobile_ShowAchievementsUI extends SeqAct_OnlineSubsystemBase
`if(`notdefined(USE_GAMECENTER))
  abstract
  HideDropDown;
`else
  ;

/**
 * 이 시퀸스 액션이 로컬 유저 번호를 붙여 어떤 작업을 해야 할 때 호출됩니다.
 */
protected function InternalOnActivated()
{
  local OnlineSubsystem OnlineSubsystem;

  // 온라인 서브시스템을 구합니다.
  OnlineSubSystem = class'GameEngine'.static.GetOnlineSubsystem();
  // 온라인 서브시스템과 플레이어 인터페이스 ex 가 접근가능한지 검사합니다.
  if (OnlineSubSystem != None && OnlineSubSystem.PlayerInterfaceEx != None)
  {
    OnlineSubSystem.PlayerInterfaceEx.ShowAchievementsUI(ProcessingPlayers[0].LocalUserNum);
    FinishedProcessPlayerIndex(true);
  }
  else
  {
    FinishedProcessPlayerIndex(false);
  }
}
`endif

defaultproperties
{
  ObjName="Show Achievements UI"
}

/**
 * Mobile Show Leaderboards UI 액션은 순위표 UI 를 표시하는 데 사용됩니다.
 *
 * Copyright 1998-2012 Epic Games, Inc. All Rights Reserved.
 */
class SeqAct_Mobile_ShowLeaderboardsUI extends SeqAct_OnlineSubsystemBase
`if(`notdefined(USE_GAMECENTER))
  abstract
  HideDropDown;
`else
  ;

var() const class<OnlineStatsRead> OnlineStatsReadClass;

/**
 * 이 시퀸스 액션이 로컬 유저 번호를 붙여 어떤 작업을 해야 할 때 호출됩니다.
 */
protected function InternalOnActivated()
{
  local OnlineSubsystem OnlineSubsystem;
  local OnlineSuppliedUIInterface OnlineSuppliedUIInterface;
  local array<UniqueNetId> PlayerIds;
  local OnlineStatsRead OnlineStatsRead;
  local int i;

  // 클래스가 없으면 중단합니다.
  if (OnlineStatsReadClass == None)
  {
    return;
  }

  // 온라인 서브시스템을 구합니다.
  OnlineSubSystem = class'GameEngine'.static.GetOnlineSubsystem();
  // 온라인 서브시스템이 접근가능한지 확인합니다.
  if (OnlineSubSystem != None)
  {
    // 모든 처리중인 플레이어 배열에서 PlayerIds 배열을 만듭니다.
    for (i = 0; i < ProcessingPlayers.Length; ++i)
    {
      PlayerIds.AddItem(ProcessingPlayers[i].LocalNetId);
    }

    // 온라인 제공 UI 인터페이스를 구합니다.
    OnlineSuppliedUIInterface = OnlineSuppliedUIInterface(OnlineSubSystem.GetNamedInterface('SuppliedUI'));
    if (OnlineSuppliedUIInterface != None)
    {
      // 온라인 통계 읽기 클래스의 인스턴스를 만듭니다.
      OnlineStatsRead = new () OnlineStatsReadClass;
      if (OnlineStatsRead != None)
      {
        // 온라인 통계 UI 델리게이트에 바인딩합니다.
        OnlineSuppliedUIInterface.AddShowOnlineStatsUICompleteDelegate(InternalOnShowOnlineStatsUIComplete);

        // 온라인 통계 UI 를 표시합니다.
        OnlineSuppliedUIInterface.ShowOnlineStatsUI(PlayerIds, OnlineStatsRead);
        FinishedProcessPlayerIndex(true, true);
      }
    }
  }
  else
  {
    FinishedProcessPlayerIndex(false);
  }
}

/**
 * 제공된 통계 UI 가 닫힐 때 발동되는 델리게이트 입니다.
 */
function InternalOnShowOnlineStatsUIComplete()
{
  // 넷째 출력을 활성화시킵니다.
  ForceActivateOutput(4);
}

/**
 * 가비지 콜렉션이 일어날 수 있도록 이 키즈멧 노드가 모든 변수나 델리게이트 리퍼런스를 청소해야 하면 호출됩니다.
 *
 * @param    IsExiting      빠져나가는 중이라면 모든 것을 청소합니다.
 */
function CleanUp(optional bool IsExiting)
{
  local OnlineSubsystem OnlineSubsystem;
  local OnlineSuppliedUIInterface OnlineSuppliedUIInterface;

  Super.CleanUp(IsExiting);

  if (IsExiting)
  {
    // 온라인 서브시스템을 구합니다.
    OnlineSubSystem = class'GameEngine'.static.GetOnlineSubsystem();
    // Check that the online subsystem is accessible
    if (OnlineSubSystem != None)
    {
      // 온라인 제공 UI 인터페이스를 구합니다.
      OnlineSuppliedUIInterface = OnlineSuppliedUIInterface(OnlineSubSystem.GetNamedInterface('SuppliedUI'));
      if (OnlineSuppliedUIInterface != None)
      {
        OnlineSuppliedUIInterface.ClearShowOnlineStatsUICompleteDelegate(InternalOnShowOnlineStatsUIComplete);
      }
    }
  }
}
`endif

defaultproperties
{
  ObjName="Show Leaderboards UI"

  OutputLinks(4)=(LinkDesc="Closed")
}