Mehrere Delegiertenzuweisungen und rufen Sie in einem C# Kartenspiel Aktion sctruture

Question

Ich arbeite an einer Kartenspiel-Entwicklung in C#, und ich weiß nicht, wie folgendes zu tun:

ich meine Karten-Klasse, die hat eine Liste von Aktionen, bei denen es sich um Angriffe handelt, bei denen diese Karte ausgeführt werden kann.

Diese Angriffe sind eine benutzerdefinierte Klasse mit dem Namen Act (in dem ich im Beispiel Rules genannt habe).

Wenn ich meine Karten lade, rufe ich eine Inicialize-Methode, die ich erstellt habe, die die Liste der Karten, sowie die Liste der Angriffe jeder Karte inizialisieren.

Ich möchte in der Lage sein, meine Angriffe als Mehrfachmethoden-Aufruf mit Parametern auszudrücken, die nur aufgerufen werden, wenn ich diesen Angriff zur Ausführung anrufe.

Zum Beispiel etwas wie die

ActionList = new List<CardRule>(); 
     ActionList.Add(new CardRule() 
     { 
      Description = "Cause 20 damage, then causes burn status.", 
      Rules = Damage(20).CauseStatus(Status.Burn); 
     }); 

ich die Aktion definieren möge als mehrere Methodenaufruf, Gabe von Parametern (was ich Rules genannt),

Und nennen das Rules.Execute() um alle Methodenaufruf usw. durchzuführen.

Ich weiß, dass es etwas mit Delegierten verwandt ist, aber ich weiß nicht, wie man das anruft, mehrere Methoden mit vordefinierten Parametern aufzurufen.

Vielen Dank im Voraus und sorry für schlechtes Englisch, ich bin auch bei Stack-Überlauf neu ..

Grüße,

Answer 1

Was Sie suchen nicht wirklich ein Delegierter, sondern eine Klasse was verfolgt, was getan werden muss. Dies ist ein Muster, das häufig von flüssigen APIs verwendet wird, aber es ist relativ einfach, etwas für Ihr Beispiel zu erstellen.

Für Ihr Beispiel können Sie eine IActionConfiguration Schnittstelle haben, zum Beispiel:

public interface IActionConfiguration 
{ 
    void PerformAction(MyTarget target); 
} 

Nun, werden Sie ein paar verschiedene Implementierungen wollen. Zum Beispiel eines, den Schaden darstellt:

class DamageActionConfiguration : IActionConfiguration 
{ 
    private int m_damageStrength; 

    public DamageActionConfiguration(int strength) 
    { 
     m_damageStrength = strength; 
    } 

    public void PerformAction(MyTarget target) 
    { 
     target.Health -= strength; 
    } 
} 

und einen anderen einen Status-Effekt darstellen:

class CauseStatusActionConfiguration : IActionConfiguration 
{ 
    private Status m_status; 

    public CauseStatusActionConfiguration(Status status) 
    { 
     m_status = status; 
    } 

    public void PerformAction(MyTarget target) 
    { 
     target.StatusEffects.Add(m_status); 
    } 
} 

Nun, werden Sie auch eine eine Implementierung, die mehrere Aktionen darstellt.

class CompositeActionConfiguration : IActionConfiguration 
{ 
    private IActionConfiguration m_firstWrappedConfiguration; 
    private IActionConfiguration m_secondWrappedConfiguration; 

    public CompositeActionConfiguration(IActionConfiguration first, IActionConfiguration second) 
    { 
     m_firstWrappedConfiguration = first; 
     m_secondWrappedConfiguration = second; 
    } 

    public void PerformAction(MyTarget target) 
    { 
     m_firstWrappedConfiguration.PerformAction(); 
     m_secondWrappedConfiguration.PerformAction(); 
    } 
} 

Dies ist unglaublich vereinfacht, aber gut genug für unser Beispiel. Jetzt haben Sie eine Klasse (CompositeActionConfiguration), die mehrere Aktionen darstellen kann - alles was Sie brauchen, ist die Magie, mit der Sie sie einfach zusammenfügen können.

public static class ActionRules 
{ 

    //First, you want a few static methods which can start a chain: 
    public static IActionConfiguration Damage(int strength) 
    { 
     return new DamageActionConfiguration(strength); 
    } 

    public static IActionConfiguration Status(Status status) 
    { 
     return new CauseStatusActionConfiguration(status); 
    } 

    // Next, some extension methods which allow you to chain things together 
    // This is really the glue that makes this whole solution easy to use 
    public static IActionConfiguration WithDamage(this IActionConfiguration source, int strength) 
    { 
     return new CompositeActionConfiguration(source, Damage(strength)); 
    } 

    public static IActionConfiguration WithStatus(this IActionConfiguration source, Status status) 
    { 
     return new CompositeActionConfiguration(source, Status(status)); 
    } 
} 

Das ist es. Dies gibt Ihnen eine Lösung, die mehr oder weniger was Sie wollen. Sie würden Ihre Rules-Eigenschaft als eine IActionConfiguration definieren, dann können Sie es wie folgt verwenden: