public static int check(GlobalState globalstate)
 {
     if (check (globalstate as Conditions))
         return GlobalStateCondition.GS_SATISFIED;
     else
         return GlobalStateCondition.GS_NOT_SATISFIED;
 }

        public GlobalState this[GlobalState.StateType i]
        {
            get
            {
                return fStates[(int)i];
            }

            set
            {
                fStates[(int)i] = value;
            }
        }

 public void ChangeOperationType(GlobalState state)
 {
     switch (state)
     {
         case GlobalState.DRAG_WHITEBALL:
             SetOpeartion(dragOperation);
             break;
         case GlobalState.IDLE:
             SetOpeartion(pointerOperation);
             break;
         default:
             SetOpeartion(m_DontDoAnyOperation);
             break;
     }
 }

 private static uint PropagateAll(GlobalState g)
 {
     uint m = 0;
       while (g.gray != null) m += (uint)PropagateMark(g);
       return m;
 }

 private static void MarkTMU(GlobalState g)
 {
     GCObject u = g.tmudata;
       if (u != null) {
     do {
       u = u.gch.next;
       MakeWhite(g, u);  /* may be marked, if left from previous GC */
       ReallyMarkObject(g, u);
     } while (u != g.tmudata);
       }
 }

 public RootGCRef(GlobalState g)
 {
     this.g = g;
 }

 internal static void CheckLiveness(GlobalState g, TValue obj)
 {
     LuaAssert(!IsCollectable(obj) ||
     ((TType(obj) == obj.value.gc.gch.tt) && !IsDead(g, obj.value.gc)));
 }

 private static int TraverseTable(GlobalState g, Table h)
 {
     int i;
       int weakkey = 0;
       int weakvalue = 0;
       /*const*/ TValue mode;
       if (h.metatable != null)
     MarkObject(g, h.metatable);
       mode = gfasttm(g, h.metatable, TMS.TM_MODE);
       if ((mode != null) && TTIsString(mode)) {  /* is there a weak mode? */
       weakkey = (strchr(SValue(mode), 'k') != null) ? 1 : 0 ;
       weakvalue = (strchr(SValue(mode), 'v') != null) ? 1 : 0;
     if ((weakkey!=0) || (weakvalue!=0)) {  /* is really weak? */
       h.marked &= (byte)~(KEYWEAK | VALUEWEAK);  /* clear bits */
       h.marked |= CastByte((weakkey << KEYWEAKBIT) |
                              (weakvalue << VALUEWEAKBIT));
       h.gclist = g.weak;  /* must be cleared after GC, ... */
       g.weak = obj2gco(h);  /* ... so put in the appropriate list */
     }
       }
       if ((weakkey!=0) && (weakvalue!=0)) return 1;
       if (weakvalue==0) {
     i = h.sizearray;
     while ((i--) != 0)
       MarkValue(g, h.array[i]);
       }
       i = SizeNode(h);
       while ((i--) != 0) {
     Node n = gnode(h, i);
     LuaAssert(TType(gkey(n)) != LUATDEADKEY || TTIsNil(gval(n)));
     if (TTIsNil(gval(n)))
       RemoveEntry(n);  /* remove empty entries */
     else {
       LuaAssert(!TTIsNil(gkey(n)));
       if (weakkey==0) MarkValue(g, gkey(n));
       if (weakvalue==0) MarkValue(g, gval(n));
     }
       }
       return ((weakkey != 0) || (weakvalue != 0)) ? 1 : 0;
 }

 /*
 ** All marks are conditional because a GC may happen while the
 ** prototype is still being created
 */
 private static void TraverseProto(GlobalState g, Proto f)
 {
     int i;
       if (f.source != null) StringMark(f.source);
       for (i=0; i<f.sizek; i++)  /* mark literals */
     MarkValue(g, f.k[i]);
       for (i=0; i<f.sizeupvalues; i++) {  /* mark upvalue names */
     if (f.upvalues[i] != null)
       StringMark(f.upvalues[i]);
       }
       for (i=0; i<f.sizep; i++) {  /* mark nested protos */
     if (f.p[i] != null)
       MarkObject(g, f.p[i]);
       }
       for (i=0; i<f.sizelocvars; i++) {  /* mark local-variable names */
     if (f.locvars[i].varname != null)
       StringMark(f.locvars[i].varname);
       }
 }

 private static void RemarkUpVals(GlobalState g)
 {
     UpVal uv;
       for (uv = g.uvhead.u.l.next; uv != g.uvhead; uv = uv.u.l.next) {
     LuaAssert(uv.u.l.next.u.l.prev == uv && uv.u.l.prev.u.l.next == uv);
     if (IsGray(obj2gco(uv)))
       MarkValue(g, uv.v);
       }
 }

 public static void MakeWhite(GlobalState g, GCObject x)
 {
     x.gch.marked = (byte)(x.gch.marked & maskmarks | LuaCWhite(g));
 }

 public static byte LuaCWhite(GlobalState g)
 {
     return (byte)(g.currentwhite & WHITEBITS);
 }

 public static bool IsDead(GlobalState g, GCObject v)
 {
     return (v.gch.marked & OtherWhite(g) & WHITEBITS) != 0;
 }

 public static TValue gfasttm(GlobalState g, Table et, TMS e)
 {
     return (et == null) ? null :
     ((et.flags & (1 << (int)e)) != 0) ? null :
     luaT_gettm(et, e, g.tmname[(int)e]);
 }

 /**
  * Adds a global state to the list of global states in the game
  *
  * @param globalState
  *            the global state to add
  */
 public void addGlobalState(GlobalState globalState)
 {
     globalStates.Add(globalState);
 }

 public static void G_set(LuaState L, GlobalState s)
 {
     L.l_G = s;
 }

        private void SetState(GlobalState state)
        {

            switch (state)
            {
                case GlobalState.AddingMass:
                    lblCurrentInstruction.Text = "Add Mass";
                    lblCurrentInstruction.Visible = true;
                    chkRunning.Checked = false;
                    break;

                case GlobalState.AddingThruster:
                    lblCurrentInstruction.Text = "Add Thrusters (" + _addThrusterTo.ToString() + ")";
                    lblCurrentInstruction.Visible = true;
                    chkRunning.Checked = false;
                    break;

                case GlobalState.Running:
                    lblCurrentInstruction.Text = "";
                    lblCurrentInstruction.Visible = false;
                    break;

                default:
                    throw new ApplicationException("Unknown GlobalState: " + state.ToString());
            }

            _state = state;

        }

 /*
 ** traverse one gray object, turning it to black.
 ** Returns `quantity' traversed.
 */
 private static l_mem PropagateMark(GlobalState g)
 {
     GCObject o = g.gray;
       LuaAssert(IsGray(o));
       Gray2Black(o);
       switch (o.gch.tt) {
     case LUA_TTABLE: {
       Table h = gco2h(o);
       g.gray = h.gclist;
       if (TraverseTable(g, h) != 0)  /* table is weak? */
         Black2Gray(o);  /* keep it gray */
         return	GetUnmanagedSize(typeof(Table)) +
                 GetUnmanagedSize(typeof(TValue)) * h.sizearray +
                 GetUnmanagedSize(typeof(Node)) * SizeNode(h);
     }
     case LUA_TFUNCTION: {
       Closure cl = gco2cl(o);
       g.gray = cl.c.gclist;
       TraverseClosure(g, cl);
       return (cl.c.isC != 0) ? SizeCclosure(cl.c.nupvalues) :
                            SizeLclosure(cl.l.nupvalues);
     }
     case LUA_TTHREAD: {
       LuaState th = gco2th(o);
       g.gray = th.gclist;
       th.gclist = g.grayagain;
       g.grayagain = o;
       Black2Gray(o);
       TraverseStack(g, th);
       return	GetUnmanagedSize(typeof(LuaState)) +
                 GetUnmanagedSize(typeof(TValue)) * th.stacksize +
                 GetUnmanagedSize(typeof(CallInfo)) * th.size_ci;
     }
     case LUATPROTO: {
       Proto p = gco2p(o);
       g.gray = p.gclist;
       TraverseProto(g, p);
       return	GetUnmanagedSize(typeof(Proto)) +
                 GetUnmanagedSize(typeof(Instruction)) * p.sizecode +
                 GetUnmanagedSize(typeof(Proto)) * p.sizep +
                 GetUnmanagedSize(typeof(TValue)) * p.sizek +
                 GetUnmanagedSize(typeof(int)) * p.sizelineinfo +
                 GetUnmanagedSize(typeof(LocVar)) * p.sizelocvars +
                 GetUnmanagedSize(typeof(TString)) * p.sizeupvalues;
     }
     default: LuaAssert(0); return 0;
       }
 }

 private static void ReallyMarkObject(GlobalState g, GCObject o)
 {
     LuaAssert(IsWhite(o) && !IsDead(g, o));
       White2Gray(o);
       switch (o.gch.tt) {
     case LUA_TSTRING: {
       return;
     }
     case LUA_TUSERDATA: {
       Table mt = gco2u(o).metatable;
       Gray2Black(o);  /* udata are never gray */
       if (mt != null) MarkObject(g, mt);
       MarkObject(g, gco2u(o).env);
       return;
     }
     case LUATUPVAL: {
       UpVal uv = gco2uv(o);
       MarkValue(g, uv.v);
       if (uv.v == uv.u.value)  /* closed? */
         Gray2Black(o);  /* open upvalues are never black */
       return;
     }
     case LUA_TFUNCTION: {
       gco2cl(o).c.gclist = g.gray;
       g.gray = o;
       break;
     }
     case LUA_TTABLE: {
       gco2h(o).gclist = g.gray;
       g.gray = o;
       break;
     }
     case LUA_TTHREAD: {
       gco2th(o).gclist = g.gray;
       g.gray = o;
       break;
     }
     case LUATPROTO: {
       gco2p(o).gclist = g.gray;
       g.gray = o;
       break;
     }
     default: LuaAssert(0); break;
       }
 }

 public static void MarkObject(GlobalState g, object t)
 {
     if (IsWhite(obj2gco(t)))
         ReallyMarkObject(g, obj2gco(t));
 }