using System;
using System.Collections;
using System.Collections.Generic;
using System.Text;
using System.Runtime.InteropServices;
using System.Reflection;
using System.Reflection.Emit;
using NWScript;
using NWScript.ManagedInterfaceLayer.NWScriptManagedInterface;

using NWEffect = NWScript.NWScriptEngineStructure0;
using NWEvent = NWScript.NWScriptEngineStructure1;
using NWLocation = NWScript.NWScriptEngineStructure2;
using NWTalent = NWScript.NWScriptEngineStructure3;
using NWItemProperty = NWScript.NWScriptEngineStructure4;

namespace NWScript
{
    /// <summary>
    /// This attribute class tags a field as a "NWScript global", which is
    /// automatically saved and restored across script situation continuations.
    /// 
    /// Only fields that are of type Int32 ("int"), UInt32 ("object"),
    /// Single ("float"), or engine structure types, may be declared as
    /// NWScript globals.
    /// </summary>
    [System.AttributeUsage(System.AttributeTargets.Field)]
    public class NWScriptGlobal : System.Attribute
    {
        public NWScriptGlobal()
        {
        }
    }
}

namespace CLRScriptFramework
{

    public interface ICLRScriptImplementation
    {
        /// <summary>
        /// This helper function saves the value of all 'globals' to an object
        /// array for use with storing a saved state (e.g. a script situation).
        /// </summary>
        /// <returns>A list of global variables, to be restored by a future
        /// call to LoadScriptGlobals.</returns>
        object[] SaveScriptGlobals();

        /// <summary>
        /// This function represents the user's main script entrypoint symbol.
        /// </summary>
        /// <param name="ScriptParameters">Supplies the argument vector for the
        /// script.</param>
        /// <param name="DefaultReturnCode">Supplies the requested default
        /// return code if the script does not wish to specify a specific
        /// return code.</param>
        /// <returns></returns>
        Int32 ScriptMain([In] object[] ScriptParameters, [In] Int32 DefaultReturnCode);

        /// <summary>
        /// This routine is invoked when the script context is being cloned for
        /// the creation of a script situation.  Its purpose is to create a new
        /// SampleManagedNWScript object and transfer any state desired to the
        /// new script object.
        /// </summary>
        /// <returns>The cloned script object is returned.</returns>
        IGeneratedScriptProgram CloneScriptProgram();
    }

    /// <summary>
    /// This partial implementation of the sample script includes wrappers for
    /// the high level NWScript functions.  You should include the wrappers in
    /// your script object type.
    /// </summary>
    public partial class CLRScriptBase
    {

        /// <summary>
        /// The following field is the "self" constant for use within the
        /// script.
        /// </summary>
        public UInt32 OBJECT_SELF;

        /// <summary>
        /// The following constant is the "invalid" object id constant for use
        /// within the script.
        /// </summary>
        public const UInt32 OBJECT_INVALID = ManagedNWScript.OBJECT_INVALID;



        /// <summary>
        /// This datatype wraps the concept of an "action" datatype in NWScript, that
        /// is, a continued execution context.
        /// </summary>
        /// 
        public delegate void NWAction();

        /// <summary>
        /// This table is used to track pending action delegates for resume.
        /// It should not be used by user code.
        /// </summary>
        protected static Dictionary<UInt32, NWAction> ActionDelegateTable = new Dictionary<UInt32, NWAction>();

        /// <summary>
        /// This variable tracks the next available resume method id for an
        /// action delegate.  It should not be used by user code.
        /// </summary>
        protected static UInt32 NextActionDelegateId = 0;


        /// <summary>
        /// The ManagedNWScript object represents the high level script API
        /// that is used to interface with the host program.
        /// </summary>
        public ManagedNWScript ScriptHost;

        /// <summary>
        /// The following list describes the set of 'global variables' that are
        /// automatically saved and restored across script situations.
        /// </summary>
        protected static List<FieldInfo> GlobalFields;

        /// <summary>
        /// The following script program object can optionally be set to
        /// delegate unrecognized script situation ids.  This capability can be
        /// useful if, for example, we want to call a NWScript script that sets
        /// up its own script situations.  In that case, we would need to be
        /// able to dispatch those script situation resumes on the right script
        /// object.
        /// </summary>
        public IGeneratedScriptProgram DelegateScriptObject = null;

        /// <summary>
        /// This routine sets up a saved script situation for a store state
        /// request.
        /// </summary>
        /// <param name="Action">Supplies the action delegate to save for later
        /// execution.</param>
        protected void InternalSaveStateForAction(NWAction Action)
        {
            //
            // Insert the delegate into the resume method table.  The resume
            // method ID is used to look up the delegate when we are entered to
            // resume a script situation.
            //
            // Script situation IDs created by CLR script code always have the
            // top bit set.  Conversely, script situation IDs that are used by
            // JIT'd NWScript scripts don't have this bit set.  This allows the
            // resume dispatcher to distinguish between the two.
            //

            UInt32 ResumeMethodId = NextActionDelegateId++ | 0x80000000;

            ActionDelegateTable[ResumeMethodId] = Action;

            //
            // Now clone the script program, save off global variables, and
            // package the script program object's state into the VM stack for
            // later execution.
            //
            // No local variables are stored presently, as we use the CLR state
            // retained within the delegate object itself.  Note that this
            // precludes restoring a script situation from a saved game.
            //
            // N.B.  A non-zero resume PC must be set.  Otherwise, the NWScript
            //       runtime environment may not recognize that this is a
            //       resume from a script situation, versus an invocation at
            //       the entry point.
            //

            ICLRScriptImplementation ScriptImplementation = (ICLRScriptImplementation)this;

            ScriptHost.Host.Intrinsic_StoreState(ScriptImplementation.SaveScriptGlobals(), null, 1, ResumeMethodId, ScriptImplementation.CloneScriptProgram());
        }

        /// <summary>
        /// This routine is invoked to dispatch a script situation to its
        /// associated delegate.  It should be called from the main
        /// ExecuteScriptSituation handler.
        /// 
        /// Script situations dispatched via this method do NOT support loading
        /// of saved games!
        /// </summary>
        /// <param name="ScriptSituationId">Supplies the ScriptSituationId that
        /// was provided to the initial StoreState request, which is intended
        /// to uniquely identify the site within which the script situation was
        /// created.</param>
        /// <param name="Locals">Supplies an array of local variables that were
        /// provided to the initial StoreState request.  The locals may only
        /// include standard NWScript types (Int32, UInt32, Single, and engine
        /// structures).</param>
        /// <param name="ObjectSelf">Supplies the "OBJECT_SELF" object id of
        /// the object that the script is being executed over.  This may be the
        /// invalid object id (Script.OBJECT_INVALID) if no object is
        /// associated with the execute script request.</param>
        public void DispatchExecuteScriptSituation([In] UInt32 ScriptSituationId, [In] object[] Locals, [In] UInt32 ObjectSelf)
        {
            UInt32 OldOBJECT_SELF = OBJECT_SELF;

            //
            // If this was a script situation set up by CLR script code, run
            // the delegate.
            //

            if ((ScriptSituationId & 0x80000000) != 0)
            {
                //
                // Assign a new OBJECT_SELF temporarily, for the invocation, and
                // dispatch to the delegate.
                //

                try
                {
                    OBJECT_SELF = ObjectSelf;
                    ActionDelegateTable[ScriptSituationId].Invoke();
                }
                finally
                {
                    OBJECT_SELF = OldOBJECT_SELF;
                    ActionDelegateTable.Remove(ScriptSituationId);
                }
            }
            else if (DelegateScriptObject != null)
            {
                //
                // This is a script situation setup by NWScript code and we
                // have established a delegate script object (which is expected
                // to be a NWScript script object).  Dispatch the request on
                // the delegate script object.
                //

                DelegateScriptObject.ExecuteScriptSituation(ScriptSituationId, Locals, ObjectSelf);
            }
            else
            {
                throw new ApplicationException("Unable to dispatch script situation " + ScriptSituationId);
            }
        }

        /// <summary>
        /// This routine creates a default engine structure of type NWEffect.
        /// </summary>
        /// <returns>The default value engine structure is returned.</returns>
        public NWEffect GetDefaultNWEffect()
        {
            return ScriptHost.Intrinsics.Intrinsic_CreateEngineStructure0();
        }

        /// <summary>
        /// This routine compares two engine structures of type NWEffect for
        /// equality.
        /// </summary>
        /// <param name="Effect1">Supplies the first engine structure.</param>
        /// <param name="Effect2">Supplies the second engine structure.</param>
        /// <returns>The routine returns true of the engine structures are
        /// logically equal.</returns>
        public bool EqualNWEffects(NWEffect Effect1, NWEffect Effect2)
        {
            return ScriptHost.Intrinsics.Intrinsic_CompareEngineStructure0(Effect1, Effect2);
        }

        /// <summary>
        /// This routine creates a default engine structure of type NWEvent.
        /// </summary>
        /// <returns>The default value engine structure is returned.</returns>
        public NWEvent GetDefaultNWEvent()
        {
            return ScriptHost.Intrinsics.Intrinsic_CreateEngineStructure1();
        }

        /// <summary>
        /// This routine compares two engine structures of type NWEvent for
        /// equality.
        /// </summary>
        /// <param name="Effect1">Supplies the first engine structure.</param>
        /// <param name="Effect2">Supplies the second engine structure.</param>
        /// <returns>The routine returns true of the engine structures are
        /// logically equal.</returns>
        public bool EqualNWEvents(NWEvent Event1, NWEvent Event2)
        {
            return ScriptHost.Intrinsics.Intrinsic_CompareEngineStructure1(Event1, Event2);
        }

        /// <summary>
        /// This routine creates a default engine structure of type NWLocation.
        /// </summary>
        /// <returns>The default value engine structure is returned.</returns>
        public NWLocation GetDefaultNWLocation()
        {
            return ScriptHost.Intrinsics.Intrinsic_CreateEngineStructure2();
        }

        /// <summary>
        /// This routine compares two engine structures of type NWLocation for
        /// equality.
        /// </summary>
        /// <param name="Effect1">Supplies the first engine structure.</param>
        /// <param name="Effect2">Supplies the second engine structure.</param>
        /// <returns>The routine returns true of the engine structures are
        /// logically equal.</returns>
        public bool EqualNWLocations(NWLocation Location1, NWLocation Location2)
        {
            return ScriptHost.Intrinsics.Intrinsic_CompareEngineStructure2(Location1, Location2);
        }

        /// <summary>
        /// This routine creates a default engine structure of type NWTalent.
        /// </summary>
        /// <returns>The default value engine structure is returned.</returns>
        public NWTalent GetDefaultNWTalent()
        {
            return ScriptHost.Intrinsics.Intrinsic_CreateEngineStructure3();
        }

        /// <summary>
        /// This routine compares two engine structures of type NWTalent for
        /// equality.
        /// </summary>
        /// <param name="Effect1">Supplies the first engine structure.</param>
        /// <param name="Effect2">Supplies the second engine structure.</param>
        /// <returns>The routine returns true of the engine structures are
        /// logically equal.</returns>
        public bool EqualNWTalents(NWTalent Talent1, NWTalent Talent2)
        {
            return ScriptHost.Intrinsics.Intrinsic_CompareEngineStructure3(Talent1, Talent2);
        }

        /// <summary>
        /// This routine creates a default engine structure of type NWItemProperty.
        /// </summary>
        /// <returns>The default value engine structure is returned.</returns>
        public NWItemProperty GetDefaultNWItemProperty()
        {
            return ScriptHost.Intrinsics.Intrinsic_CreateEngineStructure4();
        }

        /// <summary>
        /// This routine compares two engine structures of type NWItemProperty
        /// for equality.
        /// </summary>
        /// <param name="Effect1">Supplies the first engine structure.</param>
        /// <param name="Effect2">Supplies the second engine structure.</param>
        /// <returns>The routine returns true of the engine structures are
        /// logically equal.</returns>
        public bool EqualNWItemProperties(NWItemProperty ItemProperty1, NWItemProperty ItemProperty2)
        {
            return ScriptHost.Intrinsics.Intrinsic_CompareEngineStructure4(ItemProperty1, ItemProperty2);
        }

        /// <summary>
        /// This function is called from the user's constructor.  Its purpose
        /// is to initialize internal library support data.
        /// </summary>
        /// <param name="Intrinsics">Supplies the JIT intrinsics interface that
        /// is used to interface with various engine structure constructs.</param>
        /// <param name="Host">Supplies the JIT host program interface that is
        /// used to interface with the host program.</param>
        protected void InitScript(NWScriptJITIntrinsics Intrinsics, INWScriptProgram Host)
        {
            //
            // Create a managed script interface object and hand over control
            // of the host and intrinsics interfaces.
            //
            // Most operations should use the managed interface wrapper and not
            // the raw intrinsics or host object methods.
            //

            ScriptHost = new ManagedNWScript(Intrinsics, Host);

            //
            // Discover the list of global variables associated with the
            // script, and set default values for globals that cannot be null.
            //

            InitGlobals();

            //
            // Set the default OBJECT_SELF value up.
            //

            OBJECT_SELF = OBJECT_INVALID;
        }

        /// <summary>
        /// This function is called from the user's copy constructor.  Its
        /// purpose is to initialize internal library support data.
        /// </summary>
        /// <param name="Other>Supplies the instance to copy data from.</param>
        protected void InitScript(CLRScriptBase Other)
        {
            ScriptHost = Other.ScriptHost;
            OBJECT_SELF = Other.OBJECT_SELF;
            DelegateScriptObject = Other.DelegateScriptObject;
        }

        /// <summary>
        /// This provides an IEnumerator for areas present in a module.
        /// </summary>
        public class AreaEnumerator : IEnumerator<uint>
        {
            public AreaEnumerator(CLRScriptBase TheScript)
            {
                Script = TheScript;
                Reset();
            }

            public void Dispose() { }

            public bool MoveNext()
            {
                if (IsReset)
                    CurrentItem = Script.GetFirstArea();
                else
                    CurrentItem = Script.GetNextArea();

                IsReset = false;

                return CurrentItem != OBJECT_INVALID;
            }

            public void Reset()
            {
                IsReset = true;
            }

            public uint Current { get { return CurrentItem; } }

            object IEnumerator.Current { get { return CurrentItem; } }

            protected CLRScriptBase Script;
            protected bool IsReset = true;
            protected UInt32 CurrentItem;
        }

        public class AreaEnumeratorHelper : IEnumerable<uint>
        {
            public AreaEnumeratorHelper(CLRScriptBase TheScript)
            {
                Script = TheScript;
            }

            public IEnumerator<uint> GetEnumerator() { return new AreaEnumerator(Script); }
            IEnumerator IEnumerable.GetEnumerator() { return new AreaEnumerator(Script); }

            protected CLRScriptBase Script;
        }

        /// <summary>
        /// This routine returns an enumerator for areas in the module.
        /// </summary>
        /// <returns>The enumerator is returned.</returns>
        public AreaEnumeratorHelper GetAreas()
        {
            return new AreaEnumeratorHelper(this);
        }

        /// <summary>
        /// This provides an IEnumerator for players present.
        /// </summary>
        public class PlayerEnumerator : IEnumerator<uint>
        {
            public PlayerEnumerator(CLRScriptBase TheScript, bool IsOwnedCharacter)
            {
                Script = TheScript;
                OwnedCharacter = IsOwnedCharacter;
                Reset();
            }

            public void Dispose() { }

            public bool MoveNext()
            {
                if (IsReset)
                    CurrentItem = Script.GetFirstPC(OwnedCharacter ? TRUE : FALSE);
                else
                    CurrentItem = Script.GetNextPC(OwnedCharacter ? TRUE : FALSE);

                IsReset = false;

                return CurrentItem != OBJECT_INVALID;
            }

            public void Reset()
            {
                IsReset = true;
            }

            public uint Current { get { return CurrentItem; } }

            object IEnumerator.Current { get { return CurrentItem; } }

            protected CLRScriptBase Script;
            protected bool IsReset = true;
            protected bool OwnedCharacter;
            protected UInt32 CurrentItem;
        }

        public class PlayerEnumeratorHelper : IEnumerable<uint>
        {
            public PlayerEnumeratorHelper(CLRScriptBase TheScript, bool IsOwnedCharacter)
            {
                Script = TheScript;
                OwnedCharacter = IsOwnedCharacter;
            }

            public IEnumerator<uint> GetEnumerator() { return new PlayerEnumerator(Script, OwnedCharacter); }
            IEnumerator IEnumerable.GetEnumerator() { return new PlayerEnumerator(Script, OwnedCharacter); }

            protected CLRScriptBase Script;
            protected bool OwnedCharacter;
        }

        /// <summary>
        /// This routine returns an enumerator for players in the module.
        /// </summary>
        /// <param name="IsOwnedCharacter">Supplies true if owned characters
        /// should be returned instead of active characters.</param>
        /// <returns>The enumerator is returned.</returns>
        public PlayerEnumeratorHelper GetPlayers(bool IsOwnedCharacter)
        {
            return new PlayerEnumeratorHelper(this, IsOwnedCharacter);
        }

        /// <summary>
        /// This provides an IEnumerator for objects present in an area.
        /// </summary>
        public class AreaObjectEnumerator : IEnumerator<uint>
        {
            public AreaObjectEnumerator(uint ObjectId, CLRScriptBase TheScript)
            {
                Area = ObjectId;
                Script = TheScript;
                Reset();
            }

            public void Dispose() { }

            public bool MoveNext()
            {
                if (IsReset)
                    CurrentItem = Script.GetFirstObjectInArea(Area);
                else
                    CurrentItem = Script.GetNextObjectInArea(Area);

                IsReset = false;

                return CurrentItem != OBJECT_INVALID;
            }

            public void Reset()
            {
                IsReset = true;
            }

            public uint Current { get { return CurrentItem; } }

            object IEnumerator.Current { get { return CurrentItem; } }

            protected CLRScriptBase Script;
            protected bool IsReset = true;
            protected UInt32 Area;
            protected UInt32 CurrentItem;
        }

        public class AreaObjectEnumeratorHelper : IEnumerable<uint>
        {
            public AreaObjectEnumeratorHelper(uint ObjectId, CLRScriptBase TheScript)
            {
                Area = ObjectId;
                Script = TheScript;
            }

            public IEnumerator<uint> GetEnumerator() { return new AreaObjectEnumerator(Area, Script); }
            IEnumerator IEnumerable.GetEnumerator() { return new AreaObjectEnumerator(Area, Script); }

            protected CLRScriptBase Script;
            protected UInt32 Area;
        }

        /// <summary>
        /// This routine returns an enumerator for objects in an area.
        /// </summary>
        /// <param name="AreaObject">Supplies the area object.</param>
        /// <returns>The enumerator is returned.</returns>
        public AreaObjectEnumeratorHelper GetObjectsInArea(uint AreaObject)
        {
            return new AreaObjectEnumeratorHelper(AreaObject, this);
        }

        /// <summary>
        /// This provides an IEnumerator for objects present in a container.
        /// </summary>
        public class ContainerObjectEnumerator : IEnumerator<uint>
        {
            public ContainerObjectEnumerator(uint ObjectId, CLRScriptBase TheScript)
            {
                Container = ObjectId;
                Script = TheScript;
                Reset();
            }

            public void Dispose() { }

            public bool MoveNext()
            {
                if (IsReset)
                    CurrentItem = Script.GetFirstItemInInventory(Container);
                else
                    CurrentItem = Script.GetNextItemInInventory(Container);

                IsReset = false;

                return CurrentItem != OBJECT_INVALID;
            }

            public void Reset()
            {
                IsReset = true;
            }

            public uint Current { get { return CurrentItem; } }

            object IEnumerator.Current { get { return CurrentItem; } }

            protected CLRScriptBase Script;
            protected bool IsReset = true;
            protected UInt32 Container;
            protected UInt32 CurrentItem;
        }

        public class ContainerObjectEnumeratorHelper : IEnumerable<uint>
        {
            public ContainerObjectEnumeratorHelper(uint ObjectId, CLRScriptBase TheScript)
            {
                Container = ObjectId;
                Script = TheScript;
            }

            public IEnumerator<uint> GetEnumerator() { return new ContainerObjectEnumerator(Container, Script); }
            IEnumerator IEnumerable.GetEnumerator() { return new ContainerObjectEnumerator(Container, Script); }

            protected CLRScriptBase Script;
            protected UInt32 Container;
        }

        /// <summary>
        /// This routine returns an enumerator for objects in a container.
        /// </summary>
        /// <returns>The enumerator is returned.</returns>
        public ContainerObjectEnumeratorHelper GetObjectsInContainer(uint ContainerObject)
        {
            return new ContainerObjectEnumeratorHelper(ContainerObject, this);
        }

        /// <summary>
        /// This provides an IEnumerator for objects present in a faction.
        /// </summary>
        public class FactionObjectEnumerator : IEnumerator<uint>
        {
            public FactionObjectEnumerator(uint ObjectId, bool IsPCOnly, CLRScriptBase TheScript)
            {
                FactionMember = ObjectId;
                PCOnly = IsPCOnly;
                Script = TheScript;
                Reset();
            }

            public void Dispose() { }

            public bool MoveNext()
            {
                if (IsReset)
                    CurrentItem = Script.GetFirstFactionMember(FactionMember, PCOnly ? TRUE : FALSE);
                else
                    CurrentItem = Script.GetNextFactionMember(FactionMember, PCOnly ? TRUE : FALSE);

                IsReset = false;

                return CurrentItem != OBJECT_INVALID;
            }

            public void Reset()
            {
                IsReset = true;
            }

            public uint Current { get { return CurrentItem; } }

            object IEnumerator.Current { get { return CurrentItem; } }

            protected CLRScriptBase Script;
            protected bool IsReset = true;
            protected UInt32 FactionMember;
            protected bool PCOnly;
            protected UInt32 CurrentItem;
        }

        public class FactionObjectEnumeratorHelper : IEnumerable<uint>
        {
            public FactionObjectEnumeratorHelper(uint ObjectId, bool IsPCOnly, CLRScriptBase TheScript)
            {
                FactionMember = ObjectId;
                PCOnly = IsPCOnly;
                Script = TheScript;
            }

            public IEnumerator<uint> GetEnumerator() { return new FactionObjectEnumerator(FactionMember, PCOnly, Script); }
            IEnumerator IEnumerable.GetEnumerator() { return new FactionObjectEnumerator(FactionMember, PCOnly, Script); }

            protected CLRScriptBase Script;
            protected UInt32 FactionMember;
            protected bool PCOnly;
        }

        /// <summary>
        /// This routine returns an enumerator for objects in a faction.
        /// </summary>
        /// <param name="FactionMember">Supplies a member of the faction to
        /// enumerate.</param>
        /// <param name="PCOnly">Supplies true if only PCs are to be returned.</param>
        /// <returns>The enumerator is returned.</returns>
        public FactionObjectEnumeratorHelper GetObjectsInFaction(uint FactionMember, bool PCOnly)
        {
            return new FactionObjectEnumeratorHelper(FactionMember, PCOnly, this);
        }

        /// <summary>
        /// This provides an IEnumerator for subareas overlapping a position.
        /// </summary>
        public class AreaSubAreaEnumerator : IEnumerator<uint>
        {
            public AreaSubAreaEnumerator(uint ObjectId, Vector3 ThePosition, CLRScriptBase TheScript)
            {
                Area = ObjectId;
                Position = ThePosition;
                Script = TheScript;
                Reset();
            }

            public void Dispose() { }

            public bool MoveNext()
            {
                if (IsReset)
                    CurrentItem = Script.GetFirstSubArea(Area, Position);
                else
                    CurrentItem = Script.GetNextSubArea(Area);

                IsReset = false;

                return CurrentItem != OBJECT_INVALID;
            }

            public void Reset()
            {
                IsReset = true;
            }

            public uint Current { get { return CurrentItem; } }

            object IEnumerator.Current { get { return CurrentItem; } }

            protected CLRScriptBase Script;
            protected bool IsReset = true;
            protected UInt32 Area;
            protected Vector3 Position;
            protected UInt32 CurrentItem;
        }

        public class AreaSubAreaEnumeratorHelper : IEnumerable<uint>
        {
            public AreaSubAreaEnumeratorHelper(uint ObjectId, Vector3 ThePosition, CLRScriptBase TheScript)
            {
                Area = ObjectId;
                Position = ThePosition;
                Script = TheScript;
            }

            public IEnumerator<uint> GetEnumerator() { return new AreaSubAreaEnumerator(Area, Position, Script); }
            IEnumerator IEnumerable.GetEnumerator() { return new AreaSubAreaEnumerator(Area, Position, Script); }

            protected CLRScriptBase Script;
            protected UInt32 Area;
            protected Vector3 Position;
        }

        /// <summary>
        /// This routine routines an enumerator for subareas overlapping a
        /// position.
        /// </summary>
        /// <param name="AreaObject">Supplies the area object.</param>
        /// <param name="Position">Supplies the position in the area to
        /// enumerate overlapping subareas of.</param>
        /// <returns>The enumerator is returned.</returns>
        public AreaSubAreaEnumeratorHelper GetSubAreas(uint AreaObject, Vector3 Position)
        {
            return new AreaSubAreaEnumeratorHelper(AreaObject, Position, this);
        }

        /// <summary>
        /// This provides an IEnumerator for objects in a persistent object.
        /// </summary>
        public class PersistentObjectEnumerator : IEnumerator<uint>
        {
            public PersistentObjectEnumerator(uint ObjectId, int TheResidentObjectType, int ThePersistentZone, CLRScriptBase TheScript)
            {
                PersistentObject = ObjectId;
                ResidentObjectType = TheResidentObjectType;
                PersistentZone = ThePersistentZone;
                Script = TheScript;
                Reset();
            }

            public void Dispose() { }

            public bool MoveNext()
            {
                if (IsReset)
                    CurrentItem = Script.GetFirstInPersistentObject(PersistentObject, ResidentObjectType, PersistentZone);
                else
                    CurrentItem = Script.GetNextInPersistentObject(PersistentObject, ResidentObjectType, PersistentZone);

                IsReset = false;

                return CurrentItem != OBJECT_INVALID;
            }

            public void Reset()
            {
                IsReset = true;
            }

            public uint Current { get { return CurrentItem; } }

            object IEnumerator.Current { get { return CurrentItem; } }

            protected CLRScriptBase Script;
            protected bool IsReset = true;
            protected UInt32 PersistentObject;
            protected int ResidentObjectType;
            protected int PersistentZone;
            protected UInt32 CurrentItem;
        }

        public class PersistentObjectEnumeratorHelper : IEnumerable<uint>
        {
            public PersistentObjectEnumeratorHelper(uint ObjectId, int TheResidentObjectType, int ThePersistentZone, CLRScriptBase TheScript)
            {
                PersistentObject = ObjectId;
                ResidentObjectType = TheResidentObjectType;
                PersistentZone = ThePersistentZone;
                Script = TheScript;
            }

            public IEnumerator<uint> GetEnumerator() { return new PersistentObjectEnumerator(PersistentObject, ResidentObjectType, PersistentZone, Script); }
            IEnumerator IEnumerable.GetEnumerator() { return new PersistentObjectEnumerator(PersistentObject, ResidentObjectType, PersistentZone, Script); }

            protected CLRScriptBase Script;
            protected UInt32 PersistentObject;
            protected int ResidentObjectType;
            protected int PersistentZone;
        }

        /// <summary>
        /// This routine routines an enumerator for objects in a persistent
        /// object.
        /// </summary>
        /// <param name="PersistentObject">Supplies the persistent object.</param>
        /// <param name="ResidentObjectType">Supplies the object type(s) to
        /// query.</param>
        /// <param name="PersistentZone">Supplies the persistent zone
        /// (PERSISTENT_ZONE_ACTIVE, PERSISTENT_ZONE_FOLLOW).</param>
        /// <returns>The enumerator is returned.</returns>
        public PersistentObjectEnumeratorHelper GetObjectsInPersistentObject(uint PersistentObject, int ResidentObjectType, int PersistentZone)
        {
            return new PersistentObjectEnumeratorHelper(PersistentObject, ResidentObjectType, PersistentZone, this);
        }

        /// <summary>
        /// This provides an IEnumerator for objects in a shape.
        /// </summary>
        public class ObjectInShapeEnumerator : IEnumerator<uint>
        {
            public ObjectInShapeEnumerator(int TheShape, float TheSize, NWLocation TheLocation, bool IsLineOfSight, int TheObjectFilter, Vector3 TheOrigin, CLRScriptBase TheScript)
            {
                Shape = TheShape;
                Size = TheSize;
                Location = TheLocation;
                LineOfSight = IsLineOfSight;
                ObjectFilter = TheObjectFilter;
                Origin = TheOrigin;
                Script = TheScript;
                Reset();
            }

            public void Dispose() { }

            public bool MoveNext()
            {
                if (IsReset)
                    CurrentItem = Script.GetFirstObjectInShape(Shape, Size, Location, LineOfSight ? TRUE : FALSE, ObjectFilter, Origin);
                else
                    CurrentItem = Script.GetNextObjectInShape(Shape, Size, Location, LineOfSight ? TRUE : FALSE, ObjectFilter, Origin);

                IsReset = false;

                return CurrentItem != OBJECT_INVALID;
            }

            public void Reset()
            {
                IsReset = true;
            }

            public uint Current { get { return CurrentItem; } }

            object IEnumerator.Current { get { return CurrentItem; } }

            protected CLRScriptBase Script;
            protected bool IsReset = true;
            protected int Shape;
            protected float Size;
            protected NWLocation Location;
            protected bool LineOfSight;
            protected int ObjectFilter;
            protected Vector3 Origin;
            protected UInt32 CurrentItem;
        }
        
        public class ObjectInShapeEnumeratorHelper : IEnumerable<uint>
        {
            public ObjectInShapeEnumeratorHelper(int TheShape, float TheSize, NWLocation TheLocation, bool IsLineOfSight, int TheObjectFilter, Vector3 TheOrigin, CLRScriptBase TheScript)
            {
                Shape = TheShape;
                Size = TheSize;
                Location = TheLocation;
                LineOfSight = IsLineOfSight;
                ObjectFilter = TheObjectFilter;
                Origin = TheOrigin;
                Script = TheScript;
            }

            public IEnumerator<uint> GetEnumerator() { return new ObjectInShapeEnumerator(Shape, Size, Location, LineOfSight, ObjectFilter, Origin, Script); }
            IEnumerator IEnumerable.GetEnumerator() { return new ObjectInShapeEnumerator(Shape, Size, Location, LineOfSight, ObjectFilter, Origin, Script); }

            protected CLRScriptBase Script;
            protected int Shape;
            protected float Size;
            protected NWLocation Location;
            protected bool LineOfSight;
            protected int ObjectFilter;
            protected Vector3 Origin;
        }

        /// <summary>
        /// This routine routines an enumerator for objects in a shape.
        /// </summary>
        /// <param name="Shape">Supplies the shape (SHAPE_*).</param>
        /// <param name="Size">Supplies the size of the shape.</param>
        /// <param name="Location">Supplies the location of the shape.</param>
        /// <param name="LineOfSight">Supplies true if only line of sight from
        /// OBJECT_SELF is to be considered.</param>
        /// <param name="ObjectFilter">Supplies the object type filter mask.
        /// </param>
        /// <param name="Origin">Supplies the origin of the shape.</param>
        /// <returns>The enumerator is returned.</returns>
        public ObjectInShapeEnumeratorHelper GetObjectsInShape(int Shape, float Size, NWLocation Location, bool LineOfSight, int ObjectFilter, Vector3 Origin)
        {
            return new ObjectInShapeEnumeratorHelper(Shape, Size, Location, LineOfSight, ObjectFilter, Origin, this);
        }

        /// <summary>
        /// This provides an IEnumerator for effects attached to an object.
        /// </summary>
        public class ObjectEffectEnumerator : IEnumerator<NWEffect>
        {
            public ObjectEffectEnumerator(uint ObjectId, CLRScriptBase TheScript)
            {
                TheObject = ObjectId;
                Script = TheScript;
                Reset();
            }

            public void Dispose() { }

            public bool MoveNext()
            {
                if (IsReset)
                    CurrentItem = Script.GetFirstEffect(TheObject);
                else
                    CurrentItem = Script.GetNextEffect(TheObject);

                IsReset = false;

                return Script.GetIsEffectValid(CurrentItem) != FALSE;
            }

            public void Reset()
            {
                IsReset = true;
            }

            public NWEffect Current { get { return CurrentItem; } }

            object IEnumerator.Current { get { return CurrentItem; } }

            protected CLRScriptBase Script;
            protected bool IsReset = true;
            protected UInt32 TheObject;
            protected NWEffect CurrentItem;
        }

        public class ObjectEffectEnumeratorHelper : IEnumerable<NWEffect>
        {
            public ObjectEffectEnumeratorHelper(uint ObjectId, CLRScriptBase TheScript)
            {
                TheObject = ObjectId;
                Script = TheScript;
            }

            public IEnumerator<NWEffect> GetEnumerator() { return new ObjectEffectEnumerator(TheObject, Script); }
            IEnumerator IEnumerable.GetEnumerator() { return new ObjectEffectEnumerator(TheObject, Script); }

            protected CLRScriptBase Script;
            protected UInt32 TheObject;
        }

        /// <summary>
        /// This routine routines an enumerator for effects on an object.
        /// </summary>
        /// <param name="ObjectId">Supplies the object id to query.</param>
        /// <returns>The enumerator is returned.</returns>
        public ObjectEffectEnumeratorHelper GetObjectEffects(uint ObjectId)
        {
            return new ObjectEffectEnumeratorHelper(ObjectId, this);
        }

        /// <summary>
        /// This provides an IEnumerator for item properties attached to an
        /// object.
        /// </summary>
        public class ObjectItemPropertyEnumerator : IEnumerator<NWItemProperty>
        {
            public ObjectItemPropertyEnumerator(uint ObjectId, CLRScriptBase TheScript)
            {
                TheObject = ObjectId;
                Script = TheScript;
                Reset();
            }

            public void Dispose() { }

            public bool MoveNext()
            {
                if (IsReset)
                    CurrentItem = Script.GetFirstItemProperty(TheObject);
                else
                    CurrentItem = Script.GetNextItemProperty(TheObject);

                IsReset = false;

                return Script.GetIsItemPropertyValid(CurrentItem) != FALSE;
            }

            public void Reset()
            {
                IsReset = true;
            }

            public NWItemProperty Current { get { return CurrentItem; } }

            object IEnumerator.Current { get { return CurrentItem; } }

            protected CLRScriptBase Script;
            protected bool IsReset = true;
            protected UInt32 TheObject;
            protected NWItemProperty CurrentItem;
        }

        public class ObjectItemPropertyEnumeratorHelper : IEnumerable<NWItemProperty>
        {
            public ObjectItemPropertyEnumeratorHelper(uint ObjectId, CLRScriptBase TheScript)
            {
                TheObject = ObjectId;
                Script = TheScript;
            }

            public IEnumerator<NWItemProperty> GetEnumerator() { return new ObjectItemPropertyEnumerator(TheObject, Script); }
            IEnumerator IEnumerable.GetEnumerator() { return new ObjectItemPropertyEnumerator(TheObject, Script); }

            protected CLRScriptBase Script;
            protected UInt32 TheObject;
        }

        /// <summary>
        /// This routine routines an enumerator for item properties on an item.
        /// </summary>
        /// <param name="ItemObject">Supplies the item object to query.</param>
        /// <returns>The enumerator is returned.</returns>
        public ObjectItemPropertyEnumeratorHelper GetItemPropertiesOnItem(uint ItemObject)
        {
            return new ObjectItemPropertyEnumeratorHelper(ItemObject, this);
        }

        /// <summary>
        /// This provides an IEnumerator for entering players.
        /// </summary>
        public class EnteringPlayerEnumerator : IEnumerator<uint>
        {
            public EnteringPlayerEnumerator(CLRScriptBase TheScript)
            {
                Script = TheScript;
                Reset();
            }

            public void Dispose() { }

            public bool MoveNext()
            {
                if (IsReset)
                    CurrentItem = Script.GetFirstEnteringPC();
                else
                    CurrentItem = Script.GetNextEnteringPC();

                IsReset = false;

                return CurrentItem != OBJECT_INVALID;
            }

            public void Reset()
            {
                IsReset = true;
            }

            public uint Current { get { return CurrentItem; } }

            object IEnumerator.Current { get { return CurrentItem; } }

            protected CLRScriptBase Script;
            protected bool IsReset = true;
            protected UInt32 CurrentItem;
        }

        public class EnteringPlayerEnumeratorHelper : IEnumerable<uint>
        {
            public EnteringPlayerEnumeratorHelper(CLRScriptBase TheScript)
            {
                Script = TheScript;
            }

            public IEnumerator<uint> GetEnumerator() { return new EnteringPlayerEnumerator(Script); }
            IEnumerator IEnumerable.GetEnumerator() { return new EnteringPlayerEnumerator(Script); }

            protected CLRScriptBase Script;
        }

        /// <summary>
        /// This routine routines an enumerator for entering players.
        /// </summary>
        /// <returns>The enumerator is returned.</returns>
        public EnteringPlayerEnumeratorHelper GetEnteringPlayers()
        {
            return new EnteringPlayerEnumeratorHelper(this);
        }

        /// <summary>
        /// This provides an IEnumerator for roster members.
        /// </summary>
        public class RosterMemberEnumerator : IEnumerator<string>
        {
            public RosterMemberEnumerator(CLRScriptBase TheScript)
            {
                Script = TheScript;
                Reset();
            }

            public void Dispose() { }

            public bool MoveNext()
            {
                if (IsReset)
                    CurrentItem = Script.GetFirstRosterMember();
                else
                    CurrentItem = Script.GetNextRosterMember();

                IsReset = false;

                return CurrentItem != "";
            }

            public void Reset()
            {
                IsReset = true;
            }

            public string Current { get { return CurrentItem; } }

            object IEnumerator.Current { get { return CurrentItem; } }

            protected CLRScriptBase Script;
            protected bool IsReset = true;
            protected string CurrentItem;
        }

        public class RosterMemberEnumeratorHelper : IEnumerable<string>
        {
            public RosterMemberEnumeratorHelper(CLRScriptBase TheScript)
            {
                Script = TheScript;
            }

            public IEnumerator<string> GetEnumerator() { return new RosterMemberEnumerator(Script); }
            IEnumerator IEnumerable.GetEnumerator() { return new RosterMemberEnumerator(Script); }

            protected CLRScriptBase Script;
        }

        /// <summary>
        /// This routine routines an enumerator for roster members.
        /// </summary>
        /// <returns>The enumerator is returned.</returns>
        public RosterMemberEnumeratorHelper GetRosterMembers()
        {
            return new RosterMemberEnumeratorHelper(this);
        }

        /// <summary>
        /// This function sets up global variable support.  It discovers a list
        /// of all fields that have been attributed with the [NWScriptGlobal]
        /// attribution on the current class.  Its purpose is to allow for
        /// automatic save and restore of these values across a script situation.
        /// </summary>
        protected void InitGlobals()
        {
            Type ThisType = GetType();
            bool CreateGlobalFields = true;

            if (GlobalFields == null)
                GlobalFields = new List<FieldInfo>();
            else
                CreateGlobalFields = false;

            foreach (FieldInfo Field in ThisType.GetFields(BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic))
            {
                if (Field.GetCustomAttributes(typeof(NWScriptGlobal), false).Length == 0)
                    continue;

                if (CreateGlobalFields)
                {
                    //
                    // Verify that a valid type was specified for all globals.
                    // If not, complain in the server log.
                    //

                    if (!IsValidNWScriptType(Field.FieldType))
                    {
                        WriteTimestampedLogEntry(String.Format("{0}.InitGlobals: {0}.{1} is has an invalid type ({2}) for a [NWScriptGlobal].", GetType().FullName, Field.Name, Field.FieldType.FullName));
                    }
                    else
                    {
                        GlobalFields.Add(Field);
                    }
                }

                //
                // Default initialize fields that may not be null.
                //

                if (Field.GetValue(this) != null)
                    continue;

                if (Field.FieldType == typeof(string))
                    Field.SetValue(this, "");
                else if (Field.FieldType == typeof(NWScriptEngineStructure0))
                    Field.SetValue(this, ScriptHost.Intrinsics.Intrinsic_CreateEngineStructure0());
                else if (Field.FieldType == typeof(NWScriptEngineStructure1))
                    Field.SetValue(this, ScriptHost.Intrinsics.Intrinsic_CreateEngineStructure1());
                else if (Field.FieldType == typeof(NWScriptEngineStructure2))
                    Field.SetValue(this, ScriptHost.Intrinsics.Intrinsic_CreateEngineStructure2());
                else if (Field.FieldType == typeof(NWScriptEngineStructure3))
                    Field.SetValue(this, ScriptHost.Intrinsics.Intrinsic_CreateEngineStructure3());
                else if (Field.FieldType == typeof(NWScriptEngineStructure4))
                    Field.SetValue(this, ScriptHost.Intrinsics.Intrinsic_CreateEngineStructure4());
                else if (Field.FieldType == typeof(NWScriptEngineStructure5))
                    Field.SetValue(this, ScriptHost.Intrinsics.Intrinsic_CreateEngineStructure5());
                else if (Field.FieldType == typeof(NWScriptEngineStructure6))
                    Field.SetValue(this, ScriptHost.Intrinsics.Intrinsic_CreateEngineStructure6());
                else if (Field.FieldType == typeof(NWScriptEngineStructure7))
                    Field.SetValue(this, ScriptHost.Intrinsics.Intrinsic_CreateEngineStructure7());
                else if (Field.FieldType == typeof(NWScriptEngineStructure8))
                    Field.SetValue(this, ScriptHost.Intrinsics.Intrinsic_CreateEngineStructure8());
                else if (Field.FieldType == typeof(NWScriptEngineStructure9))
                    Field.SetValue(this, ScriptHost.Intrinsics.Intrinsic_CreateEngineStructure9());
            }
        }

        /// <summary>
        /// This routine determines whether a particular type represents a
        /// legal NWScript type.  Only legal NWScript types can be used in
        /// NWScriptGlobal attributed variables.
        /// </summary>
        /// <param name="ObjectType">Supplies the type to inquire
        /// about.</param>
        /// <returns>True if the type is a legal NWScript type.</returns>
        protected bool IsValidNWScriptType(Type ObjectType)
        {
            if (ObjectType == typeof(Int32))
                return true;
            else if (ObjectType == typeof(UInt32))
                return true;
            else if (ObjectType == typeof(Single))
                return true;
            else if (ObjectType == typeof(string))
                return true;
            else if (ObjectType == typeof(NWScriptEngineStructure0))
                return true;
            else if (ObjectType == typeof(NWScriptEngineStructure1))
                return true;
            else if (ObjectType == typeof(NWScriptEngineStructure2))
                return true;
            else if (ObjectType == typeof(NWScriptEngineStructure3))
                return true;
            else if (ObjectType == typeof(NWScriptEngineStructure4))
                return true;
            else if (ObjectType == typeof(NWScriptEngineStructure5))
                return true;
            else if (ObjectType == typeof(NWScriptEngineStructure6))
                return true;
            else if (ObjectType == typeof(NWScriptEngineStructure7))
                return true;
            else if (ObjectType == typeof(NWScriptEngineStructure8))
                return true;
            else if (ObjectType == typeof(NWScriptEngineStructure9))
                return true;
            else
                return false;
        }


    }
}