Utilisation correcte des interfaces dans Actionscript 3

Question

J'ai créé une interface appelée IHero i implement dans ma classe hero.as3. la classe des héros est écrite afin qu'elle puisse être héritée dans une classe de movieclip pour gérer le mouvement, etc. Mais d'une manière ou d'une autre, je n'arrive pas à comprendre comment coder ceci avec une bonne pratique.

Peut-être que je suis dans la mauvaise direction.

Je veux avoir une sous-classe movieclip, qui sera un héros par exemple.

Devrais-je simplement implémenter le IHero dans la classe Héros avec les méthodes suivantes, ou est-ce trop? - Je suppose que je cherche une réponse sur ce qui devrait être dans une interface et ce qui ne devrait pas l'être. Voici l'interface.

package com.interfaces 
{ 
    public interface IHero 
    { 
     //movement 
     function MoveLeft():void; 
     function MoveRight():void; 
     function MoveUp():void; 
     function MoveDown():void; 

     //in battle 
     function DoDamage(isCasting:Boolean):void; 
     function DoHeal():void; 
     function Flee():void; 
     function TakeDamage():void; 
     function IsAlive():Boolean; 
     function CheckDeath():void; 
     function Die():void; 
    } 
} 

Answer 1

Je pense que vous êtes sur une bonne voie , si son le droit un ou le mauvais on est toujours subjective. Mais si vous voulez aller sur cette route, je vous suggère de lire this article par Mick West. C'est quelques années, mais c'est toujours très applicable.

Je pense que vous avez vraiment deux interfaces distinctes, mais probablement plus

public interface IMoveable { 
    function moveLeft(obj:DisplayObject):void; 
    function moveRight(obj:DisplayObject):void; 
    function moveUp(obj:DisplayObject):void; 
    function moveDown(obj:DisplayObject):void; 
    function Flee(obj:DisplayObject); 
} 

public interface IFightable { 
    function doDamage(withWeapon:IEquipableWeapon); 
    function takeDamage(fromWeapon:IEquipableWeapon); 
    function get isAlive():Boolean; 
    function checkDeath():void; 
    function Die():void; 
    function doHeal(); 
    function get health():Number; 
} 

Alors ....

public class SimpleMover implements IMoveable { 
    // The movement implementation 

    // for example: 

    public funciton moveLeft(obj:DisplayObject) { 
     obj.x = obj.x -= 10; 
    } 
} 

public class SimpleFighter implements IFightable { 
    // The fighting implementation 

    private var _health:Number = 100; 

    function doDamage(withWeapon:IEquipableWeapon) { 
     _health -= withWeapon.damage; 
    } 
} 

ensuite injecter ceux dans votre sous-classe MovieClip pour votre Hero.

public class Hero extends MovieClip { 

    private var _mover:IMoveable; 
    private var _fighter:IFightable; 

    public function Hero(mover:IMoveable, fighter:IFightable) { 
     _mover = move; 
     _fighter = fighter; 
    } 

} 

Ici, vous utilisez la classe Hero à la fois comme gestionnaire de composants et Render composant, qui va un peu contre ce Ouest parle dans l'article, mais je digresse. Mais l'idée est que votre Manager (le Hero) devienne plus ou moins un orchestrateur, procurant des appels à travers lesquels n'importe quel composant est applicable; appeler des méthodes sur _mover et fighter pour faire votre travail actuel.

Il y a plusieurs avantages à utiliser une telle approche et certains inconvénients. D'abord, c'est plus complexe à mettre en place; Cela vous oblige à vraiment aimer les composants et ce que chaque bloc logique du code va faire. Mais d'un autre côté, il découpe vos implémentations les unes des autres, les rend plus testables et réutilisables. Vous pouvez également échanger des composants à tout moment (à la compilation ou à l'exécution d'ailleurs), ce qui vous donne une certaine flexibilité lors de la création de nouvelles entités.

Mais de toute façon, c'est juste une suggestion d'un paradigme légèrement différent avec lequel vous semblez flirter. Peut-être que vous aurez un peu de kilométrage. Mais donnez certainement lecture de l'article, si vous ne l'avez pas déjà fait.

Examinez également (comme vérifier l'API) pour Unity Engine qui a un modèle d'agrégation et d'héritage similaire où les interfaces sont la clé de l'abstraction.

Answer 2

Habituellement, vous voulez une définition de classe régulière qui étend MovieClip, puis définissez votre héros movieclip d'utiliser cette classe dans l'exportation pour les options de actionscript. L'interface n'est probablement pas nécessaire du tout pour votre jeu.

Answer 3

Juste pour clarifier - les interfaces sont implémentées, pas héritées. Par conséquent, peu importe le type de classe que vous créez qui implémente IHero.Pour créer un type de classe de bibliothèque qui implémente Ihero, étendez un objet d'affichage tel que Sprite ou MovieClip, puis utilisez le mot-clé implements pour indiquer que la classe implémente Ihero. Ajoutez les méthodes Ihero et vous disposez maintenant d'une classe d'objets d'affichage implémentant iHero. Cela pourrait ressembler à ceci (notez qu'aucune fonction constructeur n'est fournie)

package 
{ 
    import flash.display.Sprite; 
    import com.interfaces.IHero; 

    /** 
    * ... 
    * @author Zachary Foley 
    */ 
    public class MyDisplayObkect extends Sprite implements IHero 
    { 

     public function MoveLeft():void 
     { 
      // Add Implementation here; 
     } 

     public function MoveRight():void 
     { 
      // Add Implementation here; 
     } 

     public function MoveUp():void 
     { 
      // Add Implementation here; 
     } 

     public function MoveDown():void 
     { 
      // Add Implementation here; 
     } 

     //in battle 
     public function DoDamage(isCasting:Boolean):void 
     { 
      // Add Implementation here; 
     } 

     public function DoHeal():void 
     { 
      // Add Implementation here; 
     } 

     public function Flee():void 
     { 
      // Add Implementation here; 
     } 

     public function TakeDamage():void 
     { 
      // Add Implementation here; 
     } 
     public function IsAlive():Boolean 
     { 
      // Add Implementation here; 
     } 

     public function CheckDeath():void 
     { 
      // Add Implementation here; 
     } 

     public function Die():void 
     { 
      // Add Implementation here; 
     } 

    } 

}