public interface IPlugin
    {
        IPluginHost Host { get;set;}

        string Name { get;}
        string Description { get;}
        string Author { get;}
        string Version { get;}

        /// <summary>
        /// A string containing the code required to call this plugin's main method.
        /// The method call should start with "mervgen." since it will be placed inside
        /// of a class (MervGen) which will have an instantiated object named mervgen.
        ///
        /// i.e.: "mervgen.[name]([parameters])"
        /// </summary>
        string CallMethod { get;}

        /// <summary>
        /// A string containing the signature of this plugin's main method.
        ///
        /// i.e.: "[return type] [name]([parameters]);"
        ///
        /// Note that conditions should return bool and actions should return void by convention.
        /// </summary>
        string MethodSignature { get;}

        /// <summary>
        /// A string containing the definition of this plugin's main method.
        ///
        /// i.e.: "[return type] MervGen::[name]([parameters]) { [body] }"
        /// </summary>
        string MethodDefinition { get;}

        /// <summary>
        /// The list of phrases which will be displayed to the user.
        /// </summary>
        List<Phrase> Phrases { get;}

        /// <summary>
        /// The built-in stats that this plugin uses.
        /// </summary>
        List<Stats> RequiredStats { get;}

        /// <summary>
        /// The valid locations that this method can be called from.  This is used
        /// to determine where the method call(s) will be inserted in the generated
        /// code.
        ///
        /// For instance, a plugin which is concerned with where a player moves
        /// would likely have a single entry (PlayerMove) as its valid placement.
        /// </summary>
        List<Events> ValidPlacements { get;}

        void Initialize();
        void Dispose();

        /// <summary>
        /// Instructs the plugin to generate all source code based on the
        /// current state of its Phrases list.  The code to be generated is:
        ///
        /// - MethodSignature
        /// - MethodDefinition
        /// - Any extra methods, includes, or variables.
        ///
        /// MethodSignature and MethodDefinitions should be generated to their
        /// corresponding properties in the plugin.  All extra code should be added
        /// to the appropriate location in the PluginHost.
        /// </summary>
        void GenerateCode();
    }

    public interface IActionPlugin : IPlugin
    {
    }

    public interface IConditionPlugin : IPlugin
    {
    }

    public interface ITrigger
    {
        List<IActionPlugin> Actions { get; set; }
        List<IConditionPlugin> Conditions { get; set; }
        string Name { get; set; }
    }

    public interface IVariable
    {
        string Name { get; set; }
        string Type { get; set; }
        string Declaration { get; set; }
    }

    public interface IPluginHost
    {
        /// <summary>
        /// The triggers for this bot.
        /// </summary>
        List<ITrigger> Triggers { get; set; }

        /// <summary>
        /// The method signatures of any additional library methods which may need
        /// to be generated.
        /// </summary>
        List<string> LibraryMethodSignatures { get; set; }

        /// <summary>
        /// The method signatures of any additional library methods which may need
        /// to be generated.
        /// </summary>
        List<string> LibraryMethodDefinitions { get; set; }

        /// <summary>
        /// Any #include's (or #define's) which need to be included in the generated class.
        /// </summary>
        List<string> Includes { get; set; }

        /// <summary>
        /// Any fields which need to be generated in the class.
        /// </summary>
        List<IVariable> Variables { get; set; }
    }

    public enum Events
    {
        All,
        Tick,
        ArenaEnter,
        ArenaSettings,
        ArenaLeave,
        ArenaListEntry,
        ArenaListEnd,
        FlagGrab,
        FlagDrop,
        FlagMove,
        FlagVictory,
        FlagGameReset,
        FlagReward,
        TimedGameOver,
        SoccerGoal,
        BallMove,
        File,
        PlayerEntering,
        PlayerMove,
        PlayerWeapon,
        WatchDamage,
        PlayerDeath,
        BannerChanged,
        PlayerScore,
        PlayerPrize,
        PlayerShip,
        PlayerSpec,
        PlayerTeam,
        PlayerLeaving,
        SelfShipReset,
        SelfPrize,
        SelfUFO,
        PositionHook,
        BrickDropped,
        ObjectToggled,
        CreateTurret,
        DeleteTurret,
        ChatArena,
        ChatPublicMacro,
        ChatPublic,
        ChatTeam,
        ChatTeamPrivate,
        ChatPrivate,
        ChatPlayerWarning,
        ChatRemotePrivate,
        ChatServerError,
        ChatChannel,
        LocalCommand,
        LocalHelp,
        RemoteCommand,
        RemoteHelp,
        Init,
        Terminate
    }

    public enum Stats
    {
        PlayerDeaths,
        PlayerKills,
        PlayerShipChanges,
        PlayerFlagGrabs,
        PlayerFlagDrops,
        PlayerFlagVictories,
        PlayerFlagPoints,
        PlayerScore,
        PlayerKillPoints,
        PlayerDamageDealt,
        PlayerDamageReceived,
        PlayerTeamKills,
        PlayerMVP,
        TeamDeaths,
        TeamKills,
        TeamShipChanges,
        TeamFlagGrabs,
        TeamFlagDrops,
        TeamFlagVictories,
        TeamFlagPoints,
        TeamScore,
        TeamKillPoints,
        TeamDamageDealt,
        TeamDamageReceived,
        TeamTeamKills,
        TeamMVP,//Tracks the player with the most points in each team
        TeamMVT //Tracks the team with the most points
    }

public class MyCondition : IConditionPlugin
    {
        #region IPlugin Members
        IPluginHost host = null;
        private string name = "My Condition Plugin";
        private string author = "Wes";
        private string description = "This is a test plugin to see if the MervGen plugin architecture works";
        private string version = "1.0";
        private List<Phrase> phrases = new List<Phrase>();
        private List<Stats> stats = new List<Stats>();
        private string callMethod = "mervgen.myConditionPlugin()";
        private string methodSignature = "bool myConditionPlugin();";
        private string methodDefinition = "bool MervGen::myConditionPlugin(){ return true; }";
        private List<Events> validPlacements = new List<Events>();

        public List<Events> ValidPlacements
        {
            get { return validPlacements; }
            set { validPlacements = value; }
        }

        public string MethodDefinition
        {
            get { return methodDefinition; }
            set { methodDefinition = value; }
        }

        public string MethodSignature
        {
            get { return methodSignature; }
            set { methodSignature = value; }
        }
       
        public string CallMethod
        {
            get { return callMethod; }
            set { callMethod = value; }
        }

        public IPluginHost Host
        {
            get { return host; }
            set { host = value; }
        }

        public string Name
        {
            get { return name; }
        }

        public string Description
        {
            get { return description; }
        }

        public string Author
        {
            get { return author; }
        }

        public string Version
        {
            get { return version; }
        }

        public List<Phrase> Phrases
        {
            get { return phrases; }
        }

        public List<Stats> RequiredStats
        {
            get { return stats; }
        }


        public void Initialize()
        {
            phrases.Add(new Phrase("Player "));
            List<string> options = new List<string>();
            options.Add("any player");
            options.Add("freq 0 player");
            phrases.Add(new Phrase("player", options));

            phrases.Add(new Phrase(" enters region "));

            options = new List<string>();
            options.Add("region1");
            options.Add("region2");
            phrases.Add(new Phrase("region", options));
            phrases.Add(new Phrase(" and has bounty greater than "));
            phrases.Add(new Phrase("bty", OptionType.FillNumber));

            validPlacements.Add(Events.All);
        }

        public void Dispose()
        {
           
        }

        public void GenerateCode()
        {
           
        }

        #endregion
    }

case EVENT_PlayerMove:
      {
         Player *p = (Player*)event.p[0];
         if(mervgen.myConditionPlugin())
         {
            ...(actions for the trigger called here)
         }
      }