using System.Collections.Generic;

​

namespace Engine {

    public interface IGameActionAcceptor<T> {

        void Accept(T gameAction);

    }

    public interface IGameAction<TGameActionAcceptor> {

        void Visit(TGameActionAcceptor acceptor);

    }

    /// This is what all user defined game actions have to inherit from.

    public class BaseGameAction<TInheritingGameAction, TAcceptor> : IGameAction<TAcceptor> where TAcceptor : IGameActionAcceptor<TInheritingGameAction> {

        private TInheritingGameAction _inheritingGameAction;

        public void Init(TInheritingGameAction inheritingGameAction) {

            _inheritingGameAction = inheritingGameAction;

        }

        public void Visit(TAcceptor acceptor) {

            acceptor.Accept(_inheritingGameAction);

        }

    }

    public class ActionExecutor<TBaseGameActionAcceptor, TConcreteGameActionAcceptor> where TConcreteGameActionAcceptor: class  where TBaseGameActionAcceptor: class   {

        private List<TBaseGameActionAcceptor> _acceptors = new List<TBaseGameActionAcceptor>();

​

        public void Subscribe(TBaseGameActionAcceptor acceptor) {

            _acceptors.Add(acceptor);

        }

        public void Execute(IGameAction<TBaseGameActionAcceptor> gameAction) {

            foreach(var acceptor in _acceptors) {

                gameAction.Visit(acceptor);

            }

        }

        public void Execute(IGameAction<TConcreteGameActionAcceptor> gameAction) {

            foreach(var acceptor in _acceptors) {

                if (acceptor is TConcreteGameActionAcceptor)

                    gameAction.Visit(acceptor as TConcreteGameActionAcceptor);

            }

        }

    }

    public class BaseAction1 : BaseGameAction<BaseAction1, ABaseGameActionAcceptor> {

        public BaseAction1() {

            Init(this);

        }

    }

    public class BaseAction2 : BaseGameAction<BaseAction2, ABaseGameActionAcceptor> {

        public BaseAction2() {

            Init(this);

        }

    }

    public interface ABaseGameActionAcceptor :

        IGameActionAcceptor<BaseAction1>,

        IGameActionAcceptor<BaseAction2>

    {

​

    }

}

​

namespace Consumer {

    using Engine;

    /// Base class for all our acceptors. Sadly the consumer needs to know about this

    /// and maintain it, if they want multiple acceptors.

    public interface AGameActionAcceptor :

        ABaseGameActionAcceptor,

        IGameActionAcceptor<Action1>,

        IGameActionAcceptor<Action2>

        {

    }

    // This is what user defined actions would look like.

    // Sadly we can't pass a reference to "this" in the base constructor, hence the Init. Meh. Maybe we can factory it!

    public class Action1 : BaseGameAction<Action1, AGameActionAcceptor> {

        public Action1() {

            Init(this);

        }

    }

    public class Action2 : BaseGameAction<Action2, AGameActionAcceptor> {

        public Action2() {

            Init(this);

        }

    }

    // This is what user defined acceptors would look like.

    public class LoggingGameActionAcceptor : AGameActionAcceptor {

        public void Accept(Action1 gameAction) {

            System.Console.WriteLine("Action1");

        }

        public void Accept(Action2 gameAction) {

            System.Console.WriteLine("Action2");

        }

        public void Accept(BaseAction1 gameAction) {

            System.Console.WriteLine("BaseAction1");

        }

        public void Accept(BaseAction2 gameAction) {

            System.Console.WriteLine("BaseAction2");

        }

    }

}

​

namespace Main {

    using Engine;

    using Consumer;

    public class Program {  

        public static void Main() {

            var executor = new ActionExecutor<ABaseGameActionAcceptor, AGameActionAcceptor>();

            executor.Subscribe(new LoggingGameActionAcceptor());

​

​

            //executor.Subscribe(new FartingGameActionAcceptor());

            executor.Execute(new Action1());

            executor.Execute(new Action2());

            executor.Execute(new BaseAction1());

        }

    }

}