Wzorce projektowe w Unity: Klucz do efektywnego tworzenia gier

 

Tworzenie gier w Unity wymaga nie tylko znajomości narzędzi i technologii, ale także dobrego projektowania kodu. Wzorce projektowe, czyli sprawdzone sposoby rozwiązywania powtarzalnych problemów projektowych, są kluczowe dla budowy skalowalnych i utrzymywanych projektów. W tym artykule omówimy najważniejsze wzorce projektowe stosowane w Unity, ich zastosowania oraz korzyści, jakie przynoszą w procesie tworzenia gier.

1. Singleton

Singleton to jeden z najbardziej popularnych wzorców projektowych w Unity. Służy do zapewnienia, że w aplikacji istnieje tylko jedna instancja określonej klasy, a dostęp do niej jest globalny.

Zastosowanie w Unity:

• Zarządzanie globalnymi systemami, takimi jak menedżer gry (GameManager), menedżer audio czy system punktacji.

Implementacja:

public class GameManager : MonoBehaviour
{
    public static GameManager Instance { get; private set; }

    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
        }
        else
        {
            Destroy(gameObject);
        }
    }
}

Zalety:

• Prosta implementacja.

• Łatwy dostęp do globalnych danych i funkcji.

Wady:

• Trudno testowalny kod.

• Potencjalne ryzyko naruszenia zasad enkapsulacji.

---

2. Observer

Observer to wzorzec, który pozwala obiektom (obserwatorom) być informowanymi o zmianach stanu innego obiektu (obserwowanego). W Unity często wykorzystuje się ten wzorzec w systemach zdarzeń i notyfikacji.

Zastosowanie w Unity:

• Powiadamianie interfejsów gracza o zmianach w stanie gry, np. aktualizacji punktów czy stanu życia.

Implementacja:

public class ScoreManager : MonoBehaviour
{
    public static event Action<int> OnScoreChanged;

    private int score;

    public void AddScore(int points)
    {
        score += points;
        OnScoreChanged?.Invoke(score);
    }
}

public class UIManager : MonoBehaviour
{
    private void OnEnable()
    {
        ScoreManager.OnScoreChanged += UpdateScoreDisplay;
    }

    private void OnDisable()
    {
        ScoreManager.OnScoreChanged -= UpdateScoreDisplay;
    }

    private void UpdateScoreDisplay(int newScore)
    {
        Debug.Log($"Updated Score: {newScore}");
    }
}

Zalety:

• Luźna zależność między obiektami.

• Ułatwienie dodawania nowych funkcji.

Wady:

• Możliwe trudne do śledzenia zależności między obiektami.

• Potrzeba dbania o odpinanie obserwatorów, aby uniknąć wycieków pamięci.

---

3. Factory

Wzorzec Factory służy do tworzenia obiektów w sposób dynamiczny, bez konieczności znajomości konkretnej klasy obiektu.

Zastosowanie w Unity:

• Tworzenie wrogów, pocisków czy innych obiektów w grze z użyciem prefabrykatów.

Implementacja:

public class EnemyFactory
{
    public GameObject CreateEnemy(GameObject prefab, Vector3 position)
    {
        return Object.Instantiate(prefab, position, Quaternion.identity);
    }
}

public class GameManager : MonoBehaviour
{
    public GameObject enemyPrefab;

    private void Start()
    {
        EnemyFactory factory = new EnemyFactory();
        factory.CreateEnemy(enemyPrefab, new Vector3(0, 0, 0));
    }
}

Zalety:

• Łatwość zmiany implementacji obiektów.

• Centralizacja tworzenia instancji.

Wady:

• Możliwy wzrost złożoności kodu w przypadku rozbudowanych fabryk.

---

4. Command

Command to wzorzec, który enkapsuluje żądanie jako obiekt, umożliwiając zapisywanie, kolejkowanie i cofanie operacji.

Zastosowanie w Unity:

• Systemy kontroli gracza, zapisu historii ruchów czy cofania operacji.

Implementacja:

public interface ICommand
{
    void Execute();
    void Undo();
}

public class MoveCommand : ICommand
{
    private Transform transform;
    private Vector3 previousPosition;
    private Vector3 newPosition;

    public MoveCommand(Transform transform, Vector3 newPosition)
    {
        this.transform = transform;
        this.newPosition = newPosition;
        this.previousPosition = transform.position;
    }

    public void Execute()
    {
        transform.position = newPosition;
    }

    public void Undo()
    {
        transform.position = previousPosition;
    }
}

public class CommandInvoker
{
    private Stack<ICommand> commandHistory = new Stack<ICommand>();

    public void ExecuteCommand(ICommand command)
    {
        command.Execute();
        commandHistory.Push(command);
    }

    public void UndoLastCommand()
    {
        if (commandHistory.Count > 0)
        {
            ICommand lastCommand = commandHistory.Pop();
            lastCommand.Undo();
        }
    }
}

Zalety:

• Łatwość implementacji operacji cofania.

• Modułowość i przejrzystość kodu.

Wady:

• Możliwy wzrost liczby klas dla każdego nowego polecenia.

---

5. State

State to wzorzec umożliwiający zmianę zachowania obiektu w zależności od jego stanu wewnętrznego.

Zastosowanie w Unity:

• Modelowanie zachowań postaci, takich jak bieganie, skakanie, czy atakowanie.

Implementacja:

public interface ICharacterState
{
    void HandleInput(Character character);
}

public class IdleState : ICharacterState
{
    public void HandleInput(Character character)
    {
        Debug.Log("Character is idle");
    }
}

public class RunningState : ICharacterState
{
    public void HandleInput(Character character)
    {
        Debug.Log("Character is running");
    }
}

public class Character : MonoBehaviour
{
    private ICharacterState currentState;

    private void Start()
    {
        SetState(new IdleState());
    }

    public void SetState(ICharacterState state)
    {
        currentState = state;
    }

    private void Update()
    {
        currentState.HandleInput(this);
    }
}


  

    

      
Wzorzec
      
Zastosowanie
      
Zalety
      
Wady
    
  
  

    

      
Singleton
      
Globalne zarządzanie systemami gry
      
Prosta implementacja
      
Trudno testowalny kod
    
    

      
Observer
      
Systemy zdarzeń i powiadomień
      
Luźna zależność obiektów
      
Ryzyko wycieków pamięci
    
    

      
Factory
      
Dynamiczne tworzenie obiektów
      
Centralizacja tworzenia instancji
      
Możliwa złożoność fabryk
    
    

      
Command
      
Historia akcji, operacje cofania
      
Ułatwione cofanie operacji
      
Duża liczba klas
    
    

      
State
      
Zachowania obiektów w zależności od stanu
      
Łatwość rozbudowy
      
Większa liczba klas