Diseño de un sistema de cámara.

Pensando en un juego común, no importa el tipo de juego, es muy probable que necesitemos algún tipo de cámara. Por ejemplo:

• Cámara de depuración: controlada por teclado y mouse, con eso podemos movernos en cualquier lugar de nuestra escena.
• Cámara con secuencia de comandos: con eso podemos indicarle a la cámara que se mueva, siguiendo un camino determinado.
• Cámara de jugador
• ...

Cada uno de estos tipos de cámaras tiene su propia función de actualización. El sistema más fácil (y malo) es tener una clase de administrador de cámara con una función de actualización genérica y funciones de actualización especializadas para cada tipo de cámara. Dentro de la función de actualización genérica tenemos una declaración de cambio que, según el tipo de cámara, llama a la función de actualización adecuada.

En lugar de esto, he pensado en otro enfoque: patrón de estrategia. Movemos el comportamiento de cada cámara (método de actualización) en una clase apropiada que implemente una interfaz común. En el administrador de cámara tenemos un miembro para esa interfaz, y podemos configurar dinámicamente cualquier comportamiento que queramos.

¿Qué piensas sobre eso? ¿Qué otros sistemas me sugieres? Gracias.

Información adicional: existe la posibilidad real de que necesite más de una cámara activa, por ejemplo, para reflexiones. En resumen, debo tener en cuenta también eso.

Los patrones de estrategia me parecen una buena apuesta. Para ir un paso más allá, el administrador de su cámara debe permanecer ignorante de los tipos concretos de cámaras. Debería registrar y cambiar las implementaciones de la cámara externamente por id (utilicé una cadena para flexibilidad pero también podría ser una enumeración o un int), por ejemplo (sin verificación de errores):

public interface ICamera
{
    void Update(float dt);
    Matrix View { get; }
}

public class CameraManager
{
    private Dictionary<string, ICamera> cameras;
    private ICamera currentCamera;

    public void RegisterCamera(string id, ICamera camera) { cameras[id] = camera; }
    public void SetCamera(string id) { currentCamera = cameras[id]; }

    public void Update(float dt) { currentCamera.Update(dt); }
    public Matrix View { get { return currentCamera.View; } }
}

public class DebugCamera : ICamera {}
public class PlayerCamera : ICamera {}
public class ScriptedCamera : ICamera {}

void Test()
{
    // Create camera manager
    CameraManager cameraManager = new CameraManager();

    // Register cameras
    cameraManager.RegisterCamera("Debug", new DebugCamera());
    cameraManager.RegisterCamera("Player", new PlayerCamera());
    cameraManager.RegisterCamera("Scripted", new ScriptedCamera());

    // Change active camera
    cameraManager.SetCamera("Player");
}

Editar

Información adicional: existe la posibilidad real de que necesite más de una cámara activa, por ejemplo, para reflexiones. En resumen, debo tener en cuenta también eso.

Eso es trivial de agregar. Solo cambia currentCameraa:

List<ICamera> activeCameras = new List<ICamera>();

Cambie SetCameraa ToggleCamera (o agregue un booleano a SetCamera, su elección):

void ToggleCamera(string id)
{
    ICamera camera = cameras[id];
    if(activeCameras.Contains(camera))
        activeCameras.Remove(camera);
    else
        activeCameras.Add(camera);
}

Y cambie el Updatemétodo para actualizar todas las cámaras activas en lugar de solo la actual:

void Update(float dt) { activeCameras.ForEach(c => c.Update(dt)); }

En mi ejemplo, también necesitaría reemplazar la Viewpropiedad con un GetViewmétodo que tome la identificación de la cámara como parámetro. Pero ese es un detalle que depende de la interfaz de su cámara de todos modos:

// You could optionally add a check to see if the camera is active
Matrix GetView(string id) { return cameras[id].View; }