Using Inheritance in C# to share functions

The parent "Character" class needs to have it's non-public members declared as "protected", rather than "private" if you want the child-classes to be able to access the variables. After that you just use the "base" keyword to reference the parent, similar to the way you would use "this" to reference the current instance of the class.

For example:

//note: abstract is not a pre-requisite for inheritance
abstract class Character
{
     protected float x;
     protected float y;
     protected float z;
     //etc etc
}

public class AIBasic : Character
{
    public void move()
    {
         //purely an example
         base.x++;
         base.y++;
         base.z++;
    }
}

Inheritance isn't the best solution to this problem. Instead consider using IoC (Inversion of Control) and create separate drawing and moving classes. Then compose those into a single character instance.

Ninject is one of my favorite IoC tools and their tutorial is rather complete. In fact it demonstrates a very simple but common gaming character class.

https://github.com/ninject/ninject/wiki/Injection-Patterns

So the first thing you do is define the base class. If you want to never instantiate it, you can create an abstract class and then allow the properties and methods be overriden:

// Marking the properties as virtual allow you to override their behaviour 'by design'. Their normal
// behaviour will continue to work if you choose not to
public abstract class Character
{
     protected virtual Point Position { get;set; }
     protected virtual int Direction {get;set; }
     protected virtual Image Texture { get;set; }
     protected virtual bool Visible { get; set; }

     // Define methods you would like to partially implement or let the other class do:
     public virtual void Rotate(int directionInDegrees)
     {
          this.Direction += directionInDegrees;
     }

     public abstract void Draw();
} 

// Then use inheritance to create the classes based on this
public class Player : Character
{
     public override void Rotate(int directionInDegrees)
     {
          // Implement character specific rotate
     }

     public void Draw()
     {
          // Must implement Draw(), so that we can instantiate the class properly.
          // All methods of an abstract class must be implemented before a class is deemed
          // valid to use instantiate directly.
     }
}

public class Enemy : Character
{
   public override void Rotate()
   {
   }
}

In answer to 'inheriting' from static classes, you cannot do this. static methods belong to the class, not the instance of the object, so they cannot be inherited. They can be overridden (by use of the new keyword to show you are overriding it), but you would have to implement this for every class you create.

If you want the ability to override methods by default, you have to write methods as non-static.

mark the properties in the base class as protected, as opposed to private... then derived classes can access.