style: 명칭 변경 Game -> App or System

Game보다는 App이나 System에 가깝다

Author: ImGdevel

Assets/App/Scenes/MainSence.unity

@@ -692,7 +692,7 @@ GameObject:
   - component: {fileID: 1104447313}
   - component: {fileID: 1104447314}
   m_Layer: 0
-  m_Name: GameManager
+  m_Name: SystemManager
   m_TagString: Untagged
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0

Assets/Core/DebugConsole/README_DebugConsole.md

@@ -1,7 +1,7 @@
-# 인게임 디버그 콘솔 사용 가이드
+# 인앱 디버그 콘솔 사용 가이드
 
 ## 개요
-인게임에서 Debug.Log 메시지를 실시간으로 확인할 수 있는 관리자 콘솔입니다.
+앱 실행 중 Debug.Log 메시지를 실시간으로 확인할 수 있는 관리자 콘솔입니다.
 
 ## 주요 기능
 - **실시간 로그 표시**: 모든 Debug.Log 메시지를 실시간으로 확인
@@ -41,7 +41,7 @@ LogEntryPrefab (GameObject)
 ```
 
 ### 3. 컴포넌트 설정
-1. **InGameDebugConsole** 스크립트를 ConsolePanel에 추가
+1. **InAppDebugConsole** 스크립트를 ConsolePanel에 추가
 2. **LogEntryPrefab** 스크립트를 로그 엔트리 프리팹에 추가
 3. **DebugConsoleSettings** ScriptableObject 생성:
    - Project 창에서 우클릭 → Create → ProjectVG → Debug Console Settings
@@ -103,7 +103,7 @@ LogEntryPrefab (GameObject)
 
 ```csharp
 // 디버그 콘솔 참조
-InGameDebugConsole debugConsole = FindObjectOfType<InGameDebugConsole>();
+InAppDebugConsole debugConsole = FindObjectOfType<InAppDebugConsole>();
 
 // 특정 키워드로 필터링
 debugConsole.SetFilter("ChatManager");
@@ -151,5 +151,5 @@ debugConsole.ToggleConsole();
 2. 민감한 정보가 로그에 포함되지 않도록 주의
 3. 모바일에서는 3개 손가락 동시 터치로 콘솔 제어 (설정에서 변경 가능)
 4. 오브젝트 풀링 사용 시 Pool Size를 적절히 설정하여 메모리 사용량 조절
-5. 백그라운드 로깅 사용 시 게임 성능에 미치는 영향을 모니터링
+5. 백그라운드 로깅 사용 시 앱 성능에 미치는 영향을 모니터링
 6. 성능이 중요한 경우 `InitializePoolOnStart`를 false로 설정하여 지연 초기화 사용 

Assets/Core/Loading/LoadingManager.cs

@@ -26,15 +26,15 @@ public TaskInfo(string name, string description, float progressValue)
 
     /// <summary>
     /// 로딩 과정을 전담 관리하는 싱글톤 매니저
-    /// 실제 초기화는 GameManager가 담당하고, 이 클래스는 UI와 사용자 피드백에 집중
+    /// 실제 초기화는 SystemManager가 담당하고, 이 클래스는 UI와 사용자 피드백에 집중
     /// </summary>
     public class LoadingManager : Singleton<LoadingManager>
     {
         [Header("UI Reference")]
         [SerializeField] private LoadingUI _loadingUI;
 
         private TaskInfo _currentTask;
-        private bool _gameStarted;
+        private bool _appStarted;
 		[SerializeField] private float _autoProgressMax = 0.9f;
 		[SerializeField] private float _autoProgressSpeed = 0.25f;
 		private Coroutine _autoProgressCoroutine;
@@ -72,11 +72,11 @@ public void StartInitialization()
             {
 				UpdateTask("INITIALIZATION", "시스템 초기화 중...", 0.05f);
 				StartAutoProgress();
-				SystemManager.Instance.InitializeGame();
+				SystemManager.Instance.Initialize();
             }
             else
             {
-                Debug.LogError("[LoadingManager] GameManager가 없습니다.");
+                Debug.LogError("[LoadingManager] SystemManager가 없습니다.");
             }
         }
 
@@ -91,17 +91,17 @@ public void UpdateTask(string taskName, string description, float progress)
                 _loadingUI.UpdateTask(_currentTask);
             }
 
-            if (!_gameStarted && _currentTask.progress >= 1f)
+            if (!_appStarted && _currentTask.progress >= 1f)
             {
-                StartGame();
+                StartApp();
             }
         }
 
-        public async void StartGame()
+        public async void StartApp()
         {
-            if (_gameStarted)
+            if (_appStarted)
                 return;
-            _gameStarted = true;
+            _appStarted = true;
             if (_loadingUI != null)
             {
                 await _loadingUI.FadeOut();
@@ -120,7 +120,7 @@ private void SetupEventListeners()
         {
             if (SystemManager.Instance != null)
             {
-                SystemManager.Instance.OnGameInitialized += OnGameInitialized;
+                SystemManager.Instance.OnAppInitialized += OnAppInitialized;
                 SystemManager.Instance.OnInitializationError += OnInitializationError;
             }
         }
@@ -129,18 +129,18 @@ private void RemoveEventListeners()
         {
             if (SystemManager.Instance != null)
             {
-                SystemManager.Instance.OnGameInitialized -= OnGameInitialized;
+                SystemManager.Instance.OnAppInitialized -= OnAppInitialized;
                 SystemManager.Instance.OnInitializationError -= OnInitializationError;
             }
         }
 
-        private void OnGameInitialized()
+        private void OnAppInitialized()
         {
-            if (!_gameStarted)
+            if (!_appStarted)
             {
 				StopAutoProgress();
 				UpdateTask("INITIALIZATION", "완료", 1f);
-                StartGame();
+                StartApp();
             }
         }
 
@@ -172,7 +172,7 @@ private void StopAutoProgress()
 		private System.Collections.IEnumerator AutoProgressRoutine()
 		{
 			float p = Mathf.Clamp01(_currentTask.progress);
-			while (p < _autoProgressMax && !_gameStarted)
+            while (p < _autoProgressMax && !_appStarted)
 			{
 				p += Time.deltaTime * _autoProgressSpeed;
 				UpdateTask("INITIALIZATION", "시스템 초기화 중...", Mathf.Min(p, _autoProgressMax));

Assets/Core/Loading/LoadingUI.cs

@@ -111,7 +111,7 @@ private void InitializeUI()
             }
 
             // 초기 상태 메시지
-            UpdateStatus("게임 시작 준비 중...");
+            UpdateStatus("앱 시작 준비 중...");
         }
 
         /// <summary>

Assets/Core/Managers/SystemManager.cs

@@ -34,7 +34,7 @@ public class SystemManager : Singleton<SystemManager>
         public AudioManager AudioManager => _audioManager;
         public LoadingManager LoadingManager => _loadingManager;
 
-        public event Action OnGameInitialized;
+        public event Action OnAppInitialized;
         public event Action<string> OnInitializationError;
 
         protected override void Awake()
@@ -49,7 +49,7 @@ protected override void Awake()
             if (_autoInitializeOnStart && !_initializationKickoffDone && !IsInitialized)
             {
                 _initializationKickoffDone = true;
-                InitializeGame();
+                Initialize();
             }
         }
 
@@ -123,7 +123,7 @@ public void SetCamera(Camera camera)
             }
         }
 
-        public async void InitializeGame()
+        public async void Initialize()
         {
             if (_initializationKickoffDone && IsInitialized)
             {
@@ -138,17 +138,17 @@ public async void InitializeGame()
                 ScreenTapManager.Instance.Initialize(_camera);
             }
 
-            await InitializeGameAsync();
+            await InitializeAppAsync();
         }
 
-        public async UniTask InitializeGameAsync()
+        public async UniTask InitializeAppAsync()
         {
             try
             {
                 await InitializeManagersAsync();
                 IsInitialized = true;
-                Debug.Log("[SystemManager] 게임 시스템 준비 완료");
-                OnGameInitialized?.Invoke();
+                Debug.Log("[SystemManager] 앱 시스템 준비 완료");
+                OnAppInitialized?.Invoke();
             }
             catch (Exception ex)
             {

Assets/Docs/Design/Component_Analysis_Document.md

@@ -265,8 +265,8 @@ smoothing: 1
 
 ## 6. 연관 클래스들
 
-### 6.1 GameManager
-- 게임 전체의 초기화와 관리
+### 6.1 SystemManager
+- 앱 전체의 초기화와 관리
 - WebSocket, Session, HTTP API 클라이언트 관리
 - 시스템 간 의존성 설정
 

Assets/Docs/Design/Initial_Loading_System_Design.md

@@ -26,29 +26,29 @@
 
 - 로딩 중 상태 표시
 - 각 단계별 진행률 표시
-- 준비 완료 시 "게임 시작" 버튼 활성화
+- 준비 완료 시 "앱 시작" 버튼 활성화
 - 페이드 인/아웃 효과로 씬 전환
 
 ## 아키텍처 설계
 
-### 선택된 접근 방식: 이벤트 기반 시스템 (GameManager 중심)
+### 선택된 접근 방식: 이벤트 기반 시스템 (SystemManager 중심)
 
 **선택 이유:**
-- GameManager가 모든 씬에서 지속되는 싱글톤
+- SystemManager가 모든 씬에서 지속되는 싱글톤
 - StartupManager는 Start 씬에서만 존재
 - 이벤트 구독을 통한 효율적인 상태 관리
-- 기존 GameManager 시스템과의 완벽한 통합
+- 기존 SystemManager 시스템과의 완벽한 통합
 
 ### 시스템 구성요소
 
 ```
-GameManager (DontDestroyOnLoad)
+SystemManager (DontDestroyOnLoad)
 ├── InitializationPhase 이벤트 발생
 ├── Progress 이벤트 발생
 └── 완료/에러 이벤트 발생
     ↓ (이벤트 구독)
 LoadingManager (Start 씬 전용)
-├── GameManager 이벤트 구독
+├── SystemManager 이벤트 구독
 ├── LoadingUI 제어
 └── SceneTransitionManager 호출
     ↓
@@ -58,14 +58,14 @@ SceneTransitionManager (싱글톤)
 
 ### 이벤트 기반 동작 흐름
 
-1. **GameManager**: 초기화 진행하며 이벤트 발생
-2. **LoadingManager**: GameManager 이벤트 구독하여 UI 업데이트
+1. **SystemManager**: 초기화 진행하며 이벤트 발생
+2. **LoadingManager**: SystemManager 이벤트 구독하여 UI 업데이트
 3. **LoadingUI**: 진행 상황 표시 및 사용자 상호작용
 4. **SceneTransitionManager**: 씬 전환 관리
 
 ## 구현된 클래스
 
-### 1. GameManager (확장됨)
+### 1. SystemManager (확장됨)
 
 ```csharp
 public enum InitializationPhase
@@ -77,16 +77,16 @@ public enum InitializationPhase
     Completed
 }
 
-public class GameManager : Singleton<GameManager>
+public class SystemManager : Singleton<SystemManager>
 {
     // 이벤트
     public event Action<InitializationPhase> OnPhaseChanged;
     public event Action<float> OnProgressChanged;
-    public event Action OnGameInitialized;
+    public event Action OnAppInitialized;
     public event Action<string> OnInitializationError;
 
     // 비동기 초기화
-    public async UniTask InitializeGameAsync();
+    public async UniTask InitializeAppAsync();
 
     // 상태 조회
     public InitializationStatus GetInitializationStatus();
@@ -104,24 +104,24 @@ public class GameManager : Singleton<GameManager>
 ```csharp
 public class LoadingManager : MonoBehaviour
 {
-    // GameManager 이벤트 구독
-    private void SubscribeToGameManager();
+    // SystemManager 이벤트 구독
+    private void SubscribeToSystemManager();
 
     // 초기화 시작
     public async void StartInitialization();
 
-    // 게임 시작 (씬 전환)
-    public async void StartGame();
+    // 앱 시작 (씬 전환)
+    public async void StartApp();
 
     // 이벤트 핸들러
     private void OnPhaseChanged(InitializationPhase phase);
     private void OnProgressChanged(float progress);
-    private void OnGameInitialized();
+    private void OnAppInitialized();
 }
 ```
 
 **주요 기능:**
-- GameManager 이벤트 구독 관리
+- SystemManager 이벤트 구독 관리
 - LoadingUI와 연동
 - 초기화 완료 시 씬 전환 처리
 
@@ -176,9 +176,9 @@ public class SceneTransitionManager : Singleton<SceneTransitionManager>
 
 ```
 1. StartScene 로드
-2. LoadingManager 생성 및 GameManager 이벤트 구독
+2. LoadingManager 생성 및 SystemManager 이벤트 구독
 3. LoadingManager.StartInitialization() 호출
-4. GameManager.InitializeGameAsync() 실행
+4. SystemManager.InitializeAppAsync() 실행
    ├── Phase: InitializingManagers (0% → 40%)
    ├── Phase: ConnectingToServer (40% → 80%)
    └── Phase: LoadingResources (80% → 100%)
@@ -189,22 +189,22 @@ public class SceneTransitionManager : Singleton<SceneTransitionManager>
 ### 2. 이벤트 흐름
 
 ```
-GameManager                    LoadingManager               LoadingUI
+SystemManager                  LoadingManager               LoadingUI
     |                              |                        |
     |──OnPhaseChanged──────────────▶|                        |
     |                              |──UpdatePhase──────────▶|
     |                              |                        |
     |──OnProgressChanged───────────▶|                        |
     |                              |──UpdateProgress───────▶|
     |                              |                        |
-    |──OnGameInitialized───────────▶|                        |
+    |──OnAppInitialized────────────▶|                        |
     |                              |──ShowStartButton──────▶|
 ```
 
 ## 주요 개선사항
 
 ### 1. 이벤트 기반 아키텍처
-- **분리된 관심사**: GameManager는 초기화, LoadingManager는 UI 관리
+- **분리된 관심사**: SystemManager는 초기화, LoadingManager는 UI 관리
 - **유연한 확장**: 새로운 구독자 추가 용이
 - **생명주기 독립성**: Start 씬 전용 컴포넌트와 전역 싱글톤 분리
 
@@ -224,7 +224,7 @@ GameManager                    LoadingManager               LoadingUI
 Assets/
 ├── Core/
 │   ├── Managers/
-│   │   └── GameManager.cs (확장됨)
+│   │   └── SystemManager.cs (확장됨)
 │   └── Loading/
 │       ├── LoadingManager.cs
 │       ├── LoadingUI.cs
@@ -245,9 +245,9 @@ Assets/
 3. UI 요소들 (ProgressBar, StatusText, StartButton 등) 연결
 4. 다음 씬 이름 설정
 
-### 2. GameManager 설정
+### 2. SystemManager 설정
 
-- 기존 GameManager 설정 그대로 사용
+- 기존 SystemManager 설정 그대로 사용
 - 자동 초기화 옵션 유지 또는 LoadingManager에서 수동 호출
 
 ### 3. 씬 전환 설정
@@ -258,7 +258,7 @@ Assets/
 ## 고려사항
 
 ### 1. 성능 최적화
-- GameManager 이벤트는 Start 씬에서만 구독
+- SystemManager 이벤트는 Start 씬에서만 구독
 - 메모리 누수 방지를 위한 적절한 구독 해제
 - 불필요한 업데이트 최소화
 
@@ -274,4 +274,4 @@ Assets/
 
 ## 결론
 
-이벤트 기반 아키텍처를 통해 GameManager의 전역적 특성과 LoadingManager의 씬 전용 특성을 효과적으로 분리했습니다. 이를 통해 유지보수성과 확장성을 높이면서도 사용자에게 명확한 초기화 진행 상황을 제공할 수 있습니다.
+이벤트 기반 아키텍처를 통해 SystemManager의 전역적 특성과 LoadingManager의 씬 전용 특성을 효과적으로 분리했습니다. 이를 통해 유지보수성과 확장성을 높이면서도 사용자에게 명확한 초기화 진행 상황을 제공할 수 있습니다.