I sort of see classes as programs themselves, designed to handle a specific task. For example if you look at link, you can quite easily break it up into several different tasks, for me I'd probably have a sprite class, that will store sprite information and also be responsible for loading the sprite, then I would have another class that would take that as a parameter and would be responsible for keeping track of frame cycle.
abstract classes are those where the implementation hasn't been fully defined, say for example you have 5 different objects, each of those having the same things in common, but lets say each one of those draws differently, so each class would inherit from that abstract class, which would contain a draw method that hadn't been implemented, and each class that inherits from it would then have to implement their own draw method. Then lets say you put those into a list that would only contain instances of that abstract class, then as you go through the list you would call the draw method of that abstract class, which would then call each draw method as implemented above.
If you want to relate it to game maker, you can think of it as how each object has a step event that it defines itself, all game maker knows is that each object has a step event, and to call it when going through the object loop, but it has no idea what that step event does, hence the term abstract.
If you want to relate constructors to game maker, think how you use instance_create, when you create an instance, you are required to pass x and y coordinates. that is no different then creating a constructor that would look like:
class Link
{
Link(int x, int y)
{
// assign my x and y coordinates
}
}
and would then be instantiated like
variablename = new Link(234, 34); // my x and y coordinates
you can also define as many as these as you like as long as the parameters are different
class Link
{
Link()
{
// assign my x and y coordinates to zero as the default
}
Link(int x, int y)
{
// assign my x and y coordinates
}
}
constructors can also inherit from each other
class Link
{
Link() : this(0, 0) // call the Link(int x, int y) constructor first
{
// do whatever now
}
Link(int x, int y)
{
// assign my x and y coordinates
}
}
Last point i'm going to make, you should not use int x and int y to store the coordinates, XNA already has a class that you should use called Vector3 that takes x, y, z, as to why you should use Vector3 instead of Vector2 which just has x and y, while you are simulating working with only a 2d plane, you are still really working on a 3d plane, and all your transforms will be required to reflect that, and then it saves you the trouble of having to create a Vector3 every time you need to do a transform.
