Question

How do I make a class that for example, handles all startDrag() and stopDrag() events? There is no MovieClip for this class. I want this class to function solely as a handler for events that are used by multiple classes.

I’m making a game and I have lots of items that can be dragged and dropped, and I need a more efficient way rather than putting this code in every single item class.

So is there any other way of doing this? Right now I have to copy and paste this into every class I have that can be dragged and dropped.

public function Weapon1() 
{
        originalPosition = new Point(x,y);
        addEventListener(Event.ENTER_FRAME, onEntrance);
}
public function onEntrance(evt:Event)
{
        addEventListener(MouseEvent.MOUSE_DOWN, mousedown);
        addEventListener(MouseEvent.MOUSE_UP, mouseup);
}
public function mousedown(evt:MouseEvent)
{
        startDrag(true);
}
public function mouseup(evt:MouseEvent)
{
        stopDrag();
        if(dropTarget)
        {
            if(dropTarget.parent.name == "slot")
            {
                this.x = dropTarget.parent.x;
                this.y = dropTarget.parent.y;
            }
        }
        else
        {
            returnToPosition();
        }
    }
    else
    {
        returnToNewPosition();
    }
}
public function returnToPosition()
{
    x = originalPosition.x;
    y = originalPosition.y;
}
public function returnToNewPosition()
{
    x = newPosition.x;
    y = newPosition.y;
}

Answer 1

What you need is Inheritance which is one of the four fundamental concepts of object-oriented programming. In OOP, inheritance enables classes to take on the properties and methods of an existing base class (also called a super class).

So; You should create a base class with drag and drop logic and extend that class to create your other derived classes (also called sub-classes).

For example, here is the base class (Draggable):

package
{
    public class Draggable extends MovieClip
    {
        //Constructor

        public function Draggable()
        {
            addEventListener(Event.ADDED_TO_STAGE, onStageReady);
        }

        //Event Handlers

        protected function onStageReady(event:Event):void
        {
            addEventListener(MouseEvent.MOUSE_DOWN, mousedown);
            addEventListener(MouseEvent.MOUSE_UP, mouseup);
        }

        protected function mousedown(event:MouseEvent):void
        {
            startDrag(true);
            //more stuff here...
        }

        protected function mouseup(event:MouseEvent):void
        {
            stopDrag();
            //more stuff here...
        }
    }
}

…and here is the Weapon1 class that extends the base class:

package
{
    public class Weapon1 extends Draggable
    {
        //Constructor

        public function Weapon1()
        {
            //initialize Weapon1
        }

        //Methods, handlers, etc...
    }
}

As you see; it’s the extend keyword that enables inheritance for the Weapon1 class.
You can go on creating more weapon classes…

public class Weapon2 extends Draggable { ... }
public class Weapon3 extends Draggable { ... }
public class Weapon4 extends Draggable { ... }

Notice that the Draggable class also extends the MovieClip class to gain some other functionality. So, each class you extend from Draggable will have the functionality of both the MovieClip and Draggable classes.

References:

• Object Oriented Programming
• Inheritance
• Encapsulation
• Abstraction
• Polymorphism