I'm bored...

Well, as far as anything specific to Sentinels of the Multiverse itself, I've only coded two cards (one of which doesn't exactly fit the current API).  Right now I've probably implemented most of the model, but none of the engine.  I know one tough hurdle I'm going to hit is the fact most (all?) enumerators already defined in the .NET framework are either wrappers around other enumerators, or they throw an exception when the underlying collection is modified while being enumerated.  I'll likely have to implement my own wrapper enumerator which sets itself back to where it left off when the wrapped enumerator throws its exception.  Either that or reimplement a trigger's collection of responses using the observer pattern while not relying on any enumerators, but the former sounds much simpler.

If that's what you people believe when you see a computer working, then yes, I'm using magic, hehehehe.

Once I get the engine up to a decent point, I wouldn't mind releasing it open source.  Of course, card packs would be a completely different story, as it would contain various IP (copyrights and trademarks) of Greater Than Games, and could get me in trouble.

That must mean I'm some sort of grand warlock, yes?

Half of what you have written is what I've implemented.  However, instead of something generic like "filters" or whatnot, I'm using the Observable/Observer pattern (Reactive Framework).  Basically, the opposite of an enumerator (a push based enumerator of sorts).  Basically, anything that needs to respond to any event registers it's response (observer) with a trigger (observable), and I've designed lasting cards to have a play time, and responses have a reference to a card, and if the card is lasting, it uses it's play time (otherwise uses the current time or a custom defined time) such that all responses can then be sorted by earliest so that earlier responses are triggered first.  Also, any response can cancel the trigger, prevent further responses from responding to the trigger.  Many triggers I'm implementing in pairs, such that one trigger occurs before the action takes place (allowing the action to be cancelled before it's performed) and one that occurs after the action (so it can respond to the fact the action actually took place).  Basically, the only thing I haven't implemented yet is the code that processes each round (engine), and that's because I'll need a good amount of the model defined and set in stone so that engine is strait forward, and so that a necessary change in model doesn't adversely effect the engine.

Basic M-C-VM-V pattern (Model, Controller, View Model, View)

Right now, WPF, as I'm experienced in using ViewModels in WPF.  ASP.NET MVC should work well with ViewModels as well, and Silverlight/WP7 is just a different version of WPF.  Other views shouldn't be too difficult (for someone with experience that is) like MonoTouch, Monodroid, GTK#, etc.

    class DrawnToTheFlame : LastingCard {

        protected override bool PlayLasting() {
            return true;
        }

        public override bool CanPlay {
            get { return true; }
        }

        public override CardType Type {
            get { return CardType.Hero; }
        }

        private string[] keywords = { "Ongoing" };

        public override IEnumerable Keywords {
            get { return keywords; }
        }

        public override string GameText {
            get { return string.Empty; }
        }

        Power power = new Power() {
            GameText = "Ra deals each non-hero target 1 fire damage for each villain ongoing card in play.",
            Play = () => {
                var damageCount = Game.Villain.CardsInPlay.Where(c => c.Keywords.Contains("Ongoing")).Count();
                foreach (var target in Game.CardsInPlay.OfType().Where(t => t.CardType != CardType.Hero)) this.DamageTarget(target, damageCount, DamageType.Fire);
            },
        };
               
        public override IEnumerable Powers {
            get { return new Power[] { power }; }
        }
    }

At a stuck point, more or less, so decided to draw a random card and implement it.  (Note: Card does not compile, as there currently is no Game.CardsInPlay list.  I'm still not sure if I should make a bunch of game level lists, or if I should just create a game level player list and compose the more specific lists as needed (e.g. Game.Players.SelectMany(p => p.CardsInPlay)).)

I also have yet to implement services (request dialogs, etc)...

If I were to have game level lists, they would just be enumerable wrappers over the individual lists.  The internal debate is whether to create a game level wrapper for each possible list, or just create a player wrapper and compose the lists as needed.  (I.e. do I create public static Pile CardsInPlay { get { return players.SelectMany(p=>p.CardsInPlay);}} or do I just use Game.Players.SelectMany(p=> p.CardsInPlay) each time I need to get all cards in play?)

So I created a chm based on what I've documented of the model thus far.  I can't attach more than 192 KB at a time, so I have to provide a link.

http://www.mediafire.com/download.php?spb13h8khh8dp8h

Ah, I forgot to mention.

CHM is Compiled HTML, it's a new help file format to replace HLP.  However, starting with Windows XP SP2, Internet Explorer (and now Chrome, and maybe a few other browsers) set all files downloaded from the internet with an internet tag.  Various checks are performed by the system and applications if the tag is detected.  For EXE files, the system shows a dialog asking if you really want to run the application first, same with msiexec when an MSI is run.  When a ZIP file has the tag, every file extracted from the ZIP file has the same tag added on.  When hh sees that a CHM has the internet tag, all navigation attempts fail.  What you have to do is bring up the properties of the file (right cick -> Properties, among other methods) and unblock the file.

The first bit of actual code from the game engine to be made public.  I tried to document as well as I could.  Unfortunately, I can't post in color (or, at least, it would take me a very long time to format it here similar to how it is in Visual Studio.
using System;
using System.Collections.Generic;
using System.Linq;

namespace SotM.Utilities {

    ///
    /// This trigger fires in response to group of triggers.
    ///
    ///
    /// The type of data passed from the trigger.
    ///
    ///
    /// This special trigger filter is used to automatically subscribe
    /// all responses subscribed to it to a number of other triggers,
    /// and responds to other triggers that fire when another trigger
    /// is created, allowing that trigger to automatically be added
    /// to the trigger list.
    ///
    sealed class CompositeTrigger : IObservable>{

        private ISet> _Triggers;
        private IList _Registers;

        ///
        /// Creates a new composite trigger.
        ///
        ///
        /// A list of triggers to listen to.
        ///
        private CompositeTrigger(IEnumerable> triggers) {
            _Triggers = new HashSet>(triggers);
        }

        ///
        /// Creates a new composite trigger given a list of triggers,
        /// a trigger to add triggers, and a converter to select
        /// a trigger from the trigger.  Trigger trigger trigger
        /// trigger.
        ///
        ///
        /// The type of data passed when the update trigger is fired.
        ///
        ///
        /// The list of triggers to initialize the composite trigger
        /// with.
        ///
        ///
        /// A trigger that is fired when a new trigger should be added
        /// to the composite trigger.
        ///
        ///
        /// A function which obtains the trigger to be added from the
        /// data passed from the update trigger.
        ///
        ///
        /// An autoupdated composite trigger.
        ///
        public CompositeTrigger Create(IEnumerable> triggers, Trigger updateTrigger, Func> triggerSelector){
            var cTrigger = new CompositeTrigger(triggers);
            updateTrigger.Subscribe(new Response(DateTime.Now.AddYears(-1)) { Next = u => cTrigger.AddTrigger(triggerSelector(u.Value)) });
            return cTrigger;
        }

        ///
        /// Adds a trigger to the composite trigger.
        ///
        ///
        /// The trigger to add
        ///
        private void AddTrigger(Trigger trigger) {
            // We want to register all current registers with the
            // new trigger, but only if we haven't already registered
            // with the trigger.
            if (_Triggers.Add(trigger)) foreach (var register in _Registers) register.AddTrigger(trigger);
           
        }

        ///
        /// Registers a response with the composite trigger.  This in
        /// turn registers the response to all the composed triggers
        /// contained by the composite trigger.
        ///
        ///
        /// The response to register
        ///
        ///
        /// A registration object which can unregister from all
        /// composed triggers when unregistered.
        ///
        public override IDisposable Subscribe(IObserver> observer) {
            // Convert observable to response, as we need an actual
            // response object.
            var response = observer.AsResponse();

            // We need to create a register based on the response
            // and the list of triggers, add the register to the
            // list of registers, and then
            var register = new CompositeTriggerRegistration(response, _Triggers, this);
            _Registers.Add(register);
            return register;
        }

        ///
        /// A private class that handles the registration of responses
        /// to a composite trigger.
        ///
        ///
        /// This class handles subscribing a given response to all
        /// triggers, subscribes the response when new triggers are
        /// added, and removes all registrations of the response
        /// when the composite registration is unregistered.
        ///
        private class CompositeTriggerRegistration : IDisposable {

            private ISet _Registers;
            private CompositeTrigger _Owner;

            public Response Response { get; private set; }

            ///
            /// Creates a registration given a response and a list
            /// of triggers to register.
            ///
            ///
            /// The response to register
            ///
            ///
            /// An initial list of triggers to register to
            ///
            ///
            /// The composite trigger that owns the register.  This
            /// allows the register to remove itself from the owning
            /// composite trigger when it's unregistered.
            ///
            public CompositeTriggerRegistration(Response response, IEnumerable> triggers, CompositeTrigger owner) {
                Response = response;
                _Registers = new HashSet(triggers.Select(t => t.Subscribe(response)));
                _Owner = owner;
            }

            ///
            /// Registers the response to a new trigger.
            ///
            ///
            /// The new trigger to register to
            ///
            public void AddTrigger(Trigger trigger) {
                _Registers.Add(trigger.Subscribe(Response));
            }

            ///
            /// Unregisters the response from all triggers it is
            /// registered to.
            ///
            public void Dispose() {
                foreach (var register in _Registers) register.Dispose();
                _Owner._Registers.Remove(this);
            }
        }

    }
}