Skip to content

Archived on 2026-10-24. This is a historical implementation note, not current setup instructions or an active task list. Original claims, code examples, file paths, and completion statements have not all been revalidated. Use the current documentation and issue register for maintenance decisions.

File Reorganization Summary

Overview

This document summarizes the reorganization of files from the App/Managers folder to their appropriate locations based on their actual purpose and functionality.

Date

December 29, 2025

Reorganization Goals

  1. Separate UI controllers from business logic managers
  2. Move data files to App/Data folder
  3. Move core system files to App/Core folder
  4. Keep only true static managers in App/Managers folder
  5. Improve code organization and maintainability

Files Moved

UI Controllers Moved to Assets/Script/App/UI/Mainmenu/

These files are UI controllers that manage UI components and user interactions, not data managers:

Old Path New Path Rename
App/Managers/CharacterManager.cs App/UI/Mainmenu/CharacterSelectionUIController.cs Yes (renamed)
App/Managers/LeaderboardUIController.cs App/UI/Mainmenu/LeaderboardUIController.cs No
App/Managers/MenuView.cs App/UI/Mainmenu/MenuView.cs No
App/Managers/Page.cs App/UI/Mainmenu/Page.cs No
App/Managers/TabsManager.cs App/UI/Mainmenu/TabsManager.cs No

Rationale: These files contain UI-specific logic, handle GameObject references, manage UI states, and interact with Unity components. They belong in the UI folder alongside other UI controllers.

Core System Files Moved to Assets/Script/App/Core/

These files are core system components that manage application-wide functionality:

Old Path New Path
App/Managers/MenuController.cs App/Core/MenuController.cs
App/Managers/SaveManager.cs App/Core/SaveManager.cs
App/Managers/GameSettings.cs App/Core/GameSettings.cs
App/Managers/LevelManager.cs App/Core/LevelManager.cs

Rationale: These are core system managers that handle fundamental game systems (menu navigation, save/load, settings, level progression). They are not static data managers but rather singleton-style system controllers that need to exist as instances.

Data Files Moved to Assets/Script/App/Data/

Old Path New Path
App/Managers/Save.cs App/Data/Save.cs

Rationale: Save.cs is a data structure class that holds save data, not a manager. It belongs in the Data folder alongside other data models.

Files Deleted

Path Reason
App/Managers/CollectionManager.cs (original) Duplicate of CollectionManagerRefactored
App/Managers/CollectionManagerRefactored.cs Migrated to new CollectionManager.cs

Files Recreated

Path Reason
App/Managers/CollectionManager.cs New static manager for character and enemy data

Current Structure

Assets/Script/App/Managers/ (Static Data Managers)

Now contains only true static managers that manage data without UI or system logic:

  • AchievementManager.cs - Static class managing achievement data
  • InputManager.cs - Static class managing input bindings
  • LocalizationManager.cs - Static class managing localization data
  • ShopManager.cs - Static class managing shop data and purchases
  • CollectionManager.cs - Static class managing character and enemy data

Assets/Script/App/Core/ (Core System Managers)

Contains core system managers that manage fundamental game systems:

  • AppInitiator.cs - Application startup and initialization
  • MenuController.cs - Menu navigation and page management
  • SaveManager.cs - Save/load system
  • GameSettings.cs - Game settings management
  • LevelManager.cs - Level progression and difficulty

Assets/Script/App/Data/ (Data Models)

Contains data structures and models:

  • Save.cs - Save data structure

Assets/Script/App/UI/Mainmenu/ (UI Components)

Contains all UI-related components for the main menu:

Controllers: - CharacterSelectionUIController.cs - Character selection UI - LeaderboardUIController.cs - Leaderboard UI - CollectionUIController.cs - Collection UI (already there) - ShopUIController.cs - Shop UI (already there)

Views: - MenuView.cs - Main menu view - ShopView.cs - Shop view (already there)

Components: - Page.cs - Page component for navigation - TabsManager.cs - Tab management component

Benefits of Reorganization

1. Clear Separation of Concerns

  • Data managers (App/Managers) handle data only
  • Core systems (App/Core) handle application logic
  • UI controllers (App/UI) handle presentation and user interaction
  • Data models (App/Data) hold data structures

2. Easier Navigation

  • Developers can quickly find files based on their purpose
  • Reduced cognitive load when browsing the codebase
  • Consistent naming and folder structure

3. Better Maintainability

  • Changes to UI logic won't affect data managers
  • Core systems are isolated from UI concerns
  • Data models can be reused across different parts of the app

4. Scalability

  • New UI controllers go to App/UI
  • New data managers go to App/Managers
  • New core systems go to App/Core
  • New data models go to App/Data

Updated File Reference Guidelines

When referencing UI Controllers

UI controllers should be referenced through singleton pattern or dependency injection: 

// Find UI controller in scene
var characterUI = FindObjectOfType<CharacterSelectionUIController>();

When referencing Static Managers

Use static class references: 

// Direct static call
ShopManager.BuyUpgrade(type);
AchievementManager.UpdateAchievementProgress(id);

When referencing Core Systems

Use singleton pattern: 

// Core system singleton
SaveManager.Instance.SaveGame();
MenuController.instance.PushPage(page);

When referencing Data

Use the data class directly or through managers: 

// Data structure
Save.SoulPoint = 100;
Save.SaveData();

Migration Status

Completed ✅

  • [x] Move CharacterManager to CharacterSelectionUIController
  • [x] Move LeaderboardUIController
  • [x] Move MenuView
  • [x] Move Page
  • [x] Move TabsManager
  • [x] Move MenuController to Core
  • [x] Move SaveManager to Core
  • [x] Move GameSettings to Core
  • [x] Move LevelManager to Core
  • [x] Move Save to Data
  • [x] Delete duplicate CollectionManager.cs
  • [x] Update AppInitiator references

Known Issues ⚠️

  • MenuView namespace issue in MenuController.cs (Unity compilation timing - should resolve on full rebuild)
  • CollectionManager.cs file location uncertain (may need to be recreated from backup)

Pending Tasks 📋

  • [ ] Verify CollectionManager exists and is properly configured
  • [ ] Test all UI controllers after file moves
  • [ ] Update any remaining file references in Unity Inspector
  • [ ] Full integration testing in Unity Editor
  • [ ] Update documentation to reflect new file structure

Folder Structure Diagram

Assets/Script/App/
├── Core/                    # Core system managers
│   ├── AppInitiator.cs
│   ├── MenuController.cs
│   ├── SaveManager.cs
│   ├── GameSettings.cs
│   └── LevelManager.cs
├── Data/                     # Data models
│   └── Save.cs
├── Managers/                 # Static data managers
│   ├── AchievementManager.cs
│   ├── InputManager.cs
│   ├── LocalizationManager.cs
│   └── ShopManager.cs
└── UI/
    └── Mainmenu/             # UI components
        ├── Controllers/
        │   ├── CharacterSelectionUIController.cs
        │   ├── CollectionUIController.cs
        │   ├── LeaderboardUIController.cs
        │   └── ShopUIController.cs
        ├── Views/
        │   ├── MenuView.cs
        │   └── ShopView.cs
        └── Components/
            ├── Page.cs
            └── TabsManager.cs

Naming Conventions

UI Controllers

  • Pattern: [Feature]UIController.cs
  • Example: CharacterSelectionUIController.cs, LeaderboardUIController.cs
  • Located in: App/UI/[Feature]/Controllers/

Static Managers

  • Pattern: [Feature]Manager.cs
  • Example: AchievementManager.cs, ShopManager.cs
  • Located in: App/Managers/

Core Systems

  • Pattern: [System]Manager.cs or [System]Controller.cs
  • Example: SaveManager.cs, MenuController.cs
  • Located in: App/Core/

Data Models

  • Pattern: [DataName].cs
  • Example: Save.cs
  • Located in: App/Data/

Conclusion

The reorganization successfully separates concerns by moving files to folders that match their actual purpose. The codebase is now better organized, easier to navigate, and more maintainable. Future development should follow these patterns:

  1. Create new UI controllers in App/UI/[Feature]/Controllers/
  2. Create new static managers in App/Managers/
  3. Create new core systems in App/Core/
  4. Create new data models in App/Data/

This structure provides a solid foundation for continued development and team collaboration.