Crea un sistema basato su comportamento / componente per i giochi

Dai un'occhiata alla questa presentazione. Sembra abbastanza vicino al tipo di modello che stai cercando. Questo modello supporta comportamenti e proprietà attaccabili. Non penso che la presentazione lo menzioni, ma puoi anche creare eventi collegabili. Questa idea è simile alle proprietà di dipendenza utilizzate in WPF.

Per me questo sembra quasi un caso da manuale per l'uso del Pattern di strategia . In questo schema, i tuoi comportamenti generici possono essere definiti in interfacce che ti permetteranno di scambiare diverse implementazioni di comportamenti in fase di esecuzione (pensa a come un power-up può influenzare l'abilità di salto o di corsa del tuo personaggio).

Per esempio (forzato):

// The basic definition of the jump behavior
public interface IJumpBehavior {
    void Jump();
}

Ora puoi implementare vari tipi di salti che il tuo personaggio può usare, senza necessariamente conoscere i dettagli di ogni salto specifico:

// This is the jump the character may have when first starting
public class NormalJump : IJumpBehavior {

     public void Jump() {
         Console.WriteLine("I am jumping, and being pretty boring about it!");
     }

}

// This is the jump of a character who has consumed a power-up
public class SuperJump : IJumpBehavior {
    public void Jump() { 
         Console.WriteLine("I am all hopped up on star power, now my jumps can do damage!");
     }
}

Ogni personaggio che vuoi avere la possibilità di saltare ora può contenere solo un riferimento a un IJumpable e può iniziare a consumare le varie implementazioni

public class HeroCharacter {

    // By default this hero can perform normal jump.
    private IJumpBehavior _jumpBehavior = new NormalJump();

    public void Jump() {
        _jumpBehvaior.Jump();
    }

    // If you want to change the hero's IJumpable at runtime
    public void SetJump(IJumpBehavior jumpBehavior) {
      _jumpBehavior = jumpBehavior;
    }

}

Quindi il tuo codice può avere un aspetto simile a:

HeroCharacter myHero = new HeroCharacer();

// Outputs: "I am jumping, and being pretty boring about it!"
myHero.Jump()

// After consuming a power-up
myHero.SetJump(new SuperJump());

// Outputs: "I am all hopped up on star power, now my jumps can do damage!"
myHero.Jump();

Ora puoi facilmente riutilizzare questi comportamenti, o addirittura estenderli in seguito, se vuoi aggiungere altri tipi di salti, o creare più giochi creati su una singola piattaforma a scorrimento laterale.

Dai un'occhiata a architettura DCI un'interessante presa sulla programmazione OO che potrebbe aiutarti.

L'implementazione di un'architettura in stile DCI in C # richiede l'utilizzo di classi di dominio semplici e l'utilizzo di oggetti Context (comportamenti) con i metodi di estensione e le interfacce per consentire alle classi dominio di collaborare in ruoli diversi. Le interfacce vengono utilizzate per evidenziare i ruoli richiesti per uno scenario. Le classi di dominio implementano le interfacce (ruoli) che si applicano al loro comportamento previsto. La collaborazione tra i ruoli avviene negli oggetti di contesto (comportamento).

Potresti creare una libreria di comportamenti e ruoli comuni che possono essere condivisi tra oggetti di dominio da progetti separati.

Vedi DCI in C # per esempi di codice in C #.

Che ne è di passare un oggetto contesto in un comportamento che fornisce metodi per modificare lo stato degli sprite / oggetti interessati da un comportamento? Ora se un oggetto ha diversi comportamenti, vengono chiamati ciascuno in un ciclo che dà loro la possibilità di cambiare il contesto. Se una determinata modifica di una proprietà esclude / limita la modifica di altre proprietà, l'oggetto contesto può fornire metodi per impostare qualche tipo di flag per indicare questo fatto, oppure può semplicemente negare modifiche indesiderate.