public static int check(GlobalState globalstate) { if (check (globalstate as Conditions)) return GlobalStateCondition.GS_SATISFIED; else return GlobalStateCondition.GS_NOT_SATISFIED; }
/// <summary> /// Updates the state machine. Should be called every simulation step after the game state is loaded and before the /// entity's action is retrieved. /// </summary> public void Update() { if (GlobalState != null) { GlobalState.Run(); } if (CurrentState != null) { CurrentState.Run(); } }
/// <summary> /// Creates a new <see cref="CodeScript"/> with the kusto globals changed. /// </summary> public CodeScript WithGlobals(GlobalState newGlobals) { var kustoFactory = this.Factory.GetFactory <KustoCodeServiceFactory>(); if (kustoFactory != null) { return(WithFactory(this.Factory.WithFactory(kustoFactory.WithGlobals(newGlobals)))); } return(this); }
public int CheckGlobalState(string globalState) { int ret = GlobalStateCondition.GS_SATISFIED; GlobalState gs = data.getChapters()[currentChapter].getGlobalState(globalState); if (gs != null) { ret = ConditionChecker.check(gs); } return(ret); }
public void Update() { if (GlobalState != null) { GlobalState.Execute(Owner); } if (CurrentState != null) { CurrentState.Execute(Owner); } }
public GlobalState this[GlobalState.StateType i] { get { return fStates[(int)i]; } set { fStates[(int)i] = value; } }
private void Awake() { if (_state != null && _state != this) { Destroy(this.gameObject); } else { // DontDestroyOnLoad(this); _state = this; } }
/// <summary> /// Processes the specified message. /// </summary> /// <param name="entity">The entity.</param> /// <param name="message">The message.</param> public void ProcessMessage(TEntity entity, IMessage message) { if (CurrentState != null && CurrentState.ProcessMessage(message)) { return; } if (GlobalState != null) { GlobalState.ProcessMessage(message); } }
private static void MarkMT(GlobalState g) { int i; for (i = 0; i < NUMTAGS; i++) { if (g.mt[i] != null) { MarkObject(g, g.mt[i]); } } }
private static void markmt(GlobalState g) { int i; for (i = 0; i < NUM_TAGS; i++) { if (g.mt[i] != null) { markobject(g, g.mt[i]); } } }
protected override void innerInit() { manager_.startBtn_.enabled = false; manager_.continueBtn_.enabled = false; manager_.autoBtn_.enabled = false; GlobalState.time(2.0f, (sec, t) => { manager_.group_.alpha = t; return(true); }).finish(() => { bFinish_ = true; }); }
void debuter() { // on verifie qu'on ne lance pas deux fois le niveau 1 (qui reviendrait a lancer le niveau 2) if (!aDebute) { aDebute = true; // et on lance le niveau 1. GlobalState gs = globalState.GetComponent <GlobalState>(); gs.currentScene++; SceneManager.LoadScene(gs.currentScene); } }
private KustoCodeService(string text, GlobalState globals, KustoCode code) : base(text) { if (globals == null) { throw new ArgumentNullException(nameof(globals)); } this.kind = KustoCode.GetKind(text); this.globals = globals; this.lazyBoundCode = code; }
// 1フレーム public GlobalState oneFrame(System.Action action) { nextState_ = new GlobalState( () => { action(); return(false); }, null ); nextState_.preState_ = this; return(nextState_); }
public static void LuaCFreeAll(LuaState L) { GlobalState g = G(L); int i; g.currentwhite = (byte)(WHITEBITS | BitMask(SFIXEDBIT)); /* mask to collect all elements */ SweepWholeList(L, new RootGCRef(g)); for (i = 0; i < g.strt.size; i++) /* free all string lists */ { SweepWholeList(L, new ArrayRef(g.strt.hash, i)); } }
public override void Execute(ResolutionSessionRuntimeContext ctx) { try { var sw = Stopwatch.StartNew(); var allReached = false; while (true) { allReached = true; int timeout; using (var state = GlobalState.GetState()) { if (state.Simulated) { System.Threading.Thread.Sleep(200); return; } foreach (var m in state.Motors.Motors) { var targetPos = ctx.GetTargetPosition(m.Courronne, m.Axe); if (targetPos != null && targetPos != m.Position) { allReached = false; } } timeout = state.HardwareConfigGlobal.WaitTargetReachedInstructionTimeoutMilliseconds; } if (allReached || ctx.CancelAsked) { return; } else if (sw.ElapsedMilliseconds > timeout) { throw new Exception("Tous les moteurs n'ont pas atteint leur position dans le temps imparti"); } else { System.Threading.Thread.Sleep(10); } } } finally { ctx.ResetTargetPositions(); } }
public static void Init(GlobalState state) { if (state != null) { _state = state; BaseRenderer.UpdateState((BaseRenderer)BackgroundRenderer, state); BaseRenderer.UpdateState((BaseRenderer)MagicRenderer, state); } if (IsInitialized) { return; } _deviceManager1 = new CommonDX.DeviceManager(); _deviceManager2 = new CommonDX.DeviceManager(); _renderer1 = new DxRenderer.BackgroundComposer() { State = _state }; _renderer2 = new DxRenderer.MagicComposer() { State = _state }; BackgroundSIS = new SumoNinjaMonkey.Framework.Controls.DrawingSurfaceSIS( (gt) => { _renderer1.Update(gt); }, (tb) => { _renderer1.Render(tb); }, (dm) => { _renderer1.Initialize(dm); }, (e1, e2) => { _renderer1.InitializeUI(e1, e2); }, (uri) => { _renderer1.LoadLocalAsset(uri); }, () => { _renderer1.Unload(); }, _deviceManager1); //_renderer1, _deviceManager1); MagicSIS = new SumoNinjaMonkey.Framework.Controls.DrawingSurfaceSIS( (gt) => { _renderer2.Update(gt); }, (tb) => { _renderer2.Render(tb); }, (dm) => { _renderer2.Initialize(dm); }, (e1, e2) => { _renderer2.InitializeUI(e1, e2); }, (uri) => { _renderer2.LoadLocalAsset(uri); }, () => { _renderer2.Unload(); }, _deviceManager2); //_renderer2, _deviceManager2); IsInitialized = true; }
public static void load_stat() { try { StreamReader reader = new StreamReader(ResManager.data_path()); string json = reader.ReadToEnd(); m_state = JsonUtility.FromJson <GlobalState>(json); reader.Close(); loaded = true; } catch (Exception e) { Debug.LogError(e); } }
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 CNCViewModel() { Gs = GlobalState.Load(); InitializeHID(Gs.CNCDeviceHIDPath); //Log Gs.Log = new FixedSizedQueue <string> { Limit = 7 }; Gs.ProcessingGCode = new Queue <string>(); Gs.Log.QueueChanged += Log_QueueChanged; PropertyChanged += CNCViewModel_PropertyChanged; }
void Start() { if (instance != null && instance != this) { Destroy(this.gameObject); } else { DontDestroyOnLoad(this.gameObject); instance = this; } }
public void ClearEmptiesInventory() { IGlobalState state = new GlobalState(); state.Add("test", 8); state.Add("test2", "Steve"); Assert.AreEqual(2, state.Count()); state.Clear(); Assert.AreEqual(0, state.Count()); }
public BioFilm(EntityPreset preset, Player p) : base(preset.Position, "biofilm", 32, 32, Drawing.DrawOrder.BG_ENTITIES) { _preset = preset; if (!preset.Activated) { GlobalState.SpawnEntity(new DoorToggle(Position, 32, 32)); SetFrame(0); } else { SetFrame(1); } }
/////////////////////////////////////////////////////////////////////////////////////////////// public StringPairList ToList(bool scrub) { StringPairList list = new StringPairList(); list.Add("FileName", scrub ? PathOps.ScrubPath( GlobalState.GetBasePath(), fileName) : fileName); list.Add("StartLine", startLine.ToString()); list.Add("EndLine", endLine.ToString()); list.Add("ViaSource", viaSource.ToString()); return(list); }
private static void remarkupvals(GlobalState g) { UpVal uv; for (uv = g.uvhead.u.l.next; uv != g.uvhead; uv = uv.u.l.next) { lua_assert(uv.u.l.next.u.l.prev == uv && uv.u.l.prev.u.l.next == uv); if (isgray(obj2gco(uv))) { markvalue(g, uv.v); } } }
/// <summary> /// Handle messages. /// </summary> /// <param name="msg"> /// The message. /// </param> /// <returns> /// True if message was handled. Otherwise, false. /// </returns> public bool HandleMessage(Telegram msg) { // first see if the current state is valid and that it can handle // the message if (CurrentState != null && CurrentState.OnMessage(Owner, msg)) { return(true); } // if not, and if a global state has been implemented, send // the message to the global state return(GlobalState != null && GlobalState.OnMessage(Owner, msg)); }
public void LeaveFrom() { if (_capture != null) { _capture.Stop(); _capture.Dispose(); _capture = null; } using (var state = GlobalState.GetState()) { MainForm.Instance.Viewer.RefreshCube(state.InitialCube); } }
public void ContinueClicked() { Debug.Log("Continnue called"); var curLevel = GlobalState.CurrentLevel; var levelsUnlocked = GlobalState.LevelsUnlocked; if (curLevel + 1 > levelsUnlocked) { GlobalState.incrementLevelsUnlocked(); } SceneManager.LoadScene("LevelSelectScene"); }
public override void WhenSpawn() { ani_State = "isWalk"; CurrentState = wolf_Wander; GlobalState = wolf_Global; coroutine = CurrentState.Excute(this); StartCoroutine(coroutine); ani.SetBool("isWalk", true); StartCoroutine(GlobalState.Excute(this)); StartCoroutine(fov.DelayFieldOfView()); }
new private void Start() { base.Start(); if (player == null) { player = GlobalState.FindPlayer(); } if (xRange == -1) { xRange = myCollider.bounds.extents.x; //Get half of the collider } }
public GlobalStateManager(ServerCore server) { _server = server; GlobalState = _server.EntityStorage.LoadState(); if (GlobalState == null) { GlobalState = new GlobalState(); } _saveTimer = new Timer(o => Save(), null, 60 * 1000, 60 * 1000); }
public static void BackgroundSolve() { Task.Factory.StartNew(() => { MainForm.Instance.Viewer.RefreshCube(); try { ColorCube cube; using (var state = GlobalState.GetState()) { cube = state.InitialCube.CloneCube(); state.SolutionInCalculation = true; state.Solution = null; } Solution solution = null; using (var task = Task.Factory.StartNew(() => { solution = Modele.Solver.Solve(cube); })) { if (!task.Wait(TimeSpan.FromSeconds(5))) { throw new Exception("Timeout à la résolution"); } } using (var state = GlobalState.GetState()) { state.Solution = solution; } ResolutionSession.FromSolution(); } catch (Exception ex) { Logger.Log(ex); using (var state = GlobalState.GetState()) { state.Solution = null; } } finally { using (var state = GlobalState.GetState()) { state.SolutionInCalculation = false; } } }); }
void Start() { // GlobalState[] objs = FindObjectsOfType(typeof(GlobalState)) as GlobalState[]; if (instance != null && instance != this) { Destroy(this.gameObject); } else { DontDestroyOnLoad(this.gameObject); instance = this; } }
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 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); } }
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; } }
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; }
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 void preinit_state(LuaState L, GlobalState g) { G_set(L, g); L.stack = null; L.stacksize = 0; L.errorJmp = null; L.hook = null; L.hookmask = 0; L.basehookcount = 0; L.allowhook = 1; ResetHookCount(L); L.openupval = null; L.size_ci = 0; L.nCcalls = L.baseCcalls = 0; L.status = 0; L.base_ci = null; L.ci = null; L.savedpc = new InstructionPtr(); L.errfunc = 0; SetNilValue(Gt(L)); }
public RootGCRef(GlobalState g) { this.g = g; }
private static void TraverseStack(GlobalState g, LuaState l) { StkId o, lim; CallInfo ci; MarkValue(g, Gt(l)); lim = l.top; for (ci = l.base_ci[0]; ci < l.ci; CallInfo.Inc(ref ci)) { LuaAssert(ci.top <= l.stack_last); if (lim < ci.top) lim = ci.top; } for (o = l.stack[0]; o < l.top; StkId.Inc(ref o)) MarkValue(g, o); for (; o <= lim; StkId.Inc(ref o)) SetNilValue(o); CheckStackSizes(l, lim); }
public static int OtherWhite(GlobalState g) { return g.currentwhite ^ WHITEBITS; }
public static void MarkValue(GlobalState g, TValue o) { CheckConsistency(o); if (IsCollectable(o) && IsWhite(GCValue(o))) ReallyMarkObject(g,GCValue(o)); }
public static void MarkObject(GlobalState g, object t) { if (IsWhite(obj2gco(t))) ReallyMarkObject(g, obj2gco(t)); }
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]); }
private static void TraverseClosure(GlobalState g, Closure cl) { MarkObject(g, cl.c.env); if (cl.c.isC != 0) { int i; for (i=0; i<cl.c.nupvalues; i++) /* mark its upvalues */ MarkValue(g, cl.c.upvalue[i]); } else { int i; LuaAssert(cl.l.nupvalues == cl.l.p.nups); MarkObject(g, cl.l.p); for (i=0; i<cl.l.nupvalues; i++) /* mark its upvalues */ MarkObject(g, cl.l.upvals[i]); } }
/* ** 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); } }
public static void SetThreshold(GlobalState g) { g.GCthreshold = (uint)((g.estimate / 100) * g.gcpause); }
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; }
private static void MarkMT(GlobalState g) { int i; for (i=0; i<NUMTAGS; i++) if (g.mt[i] != null) MarkObject(g, g.mt[i]); }
public override void startElement(string namespaceURI, string sName, string qName, Dictionary<string, string> attrs) { // If no element is being subparsed, check if we must subparse something if (subParsing == NONE) { //Parse eAdventure attributes if (qName.Equals("eAdventure")) { foreach (KeyValuePair<string, string> entry in attrs) { if (entry.Key.Equals("adaptProfile")) { chapter.setAdaptationName(entry.Value.ToString()); } if (entry.Key.Equals("assessProfile")) { chapter.setAssessmentName(entry.Value.ToString()); } } } // Subparse scene else if (qName.Equals("scene")) { subParser = new SceneSubParser(chapter); subParsing = SCENE; } // Subparse slidescene else if (qName.Equals("slidescene") || qName.Equals("videoscene")) { subParser = new CutsceneSubParser(chapter); subParsing = CUTSCENE; } // Subparse book else if (qName.Equals("book")) { subParser = new BookSubParser(chapter); subParsing = BOOK; } // Subparse object else if (qName.Equals("object")) { subParser = new ItemSubParser(chapter); subParsing = OBJECT; } // Subparse player else if (qName.Equals("player")) { subParser = new PlayerSubParser(chapter); subParsing = PLAYER; } // Subparse character else if (qName.Equals("character")) { subParser = new CharacterSubParser(chapter); subParsing = CHARACTER; } // Subparse conversacion (tree conversation) else if (qName.Equals("tree-conversation")) { subParser = new TreeConversationSubParser(chapter); subParsing = CONVERSATION; } // Subparse conversation (graph conversation) else if (qName.Equals("graph-conversation")) { subParser = new GraphConversationSubParser(chapter); subParsing = CONVERSATION; } // Subparse timer else if (qName.Equals("timer")) { subParser = new TimerSubParser(chapter); subParsing = TIMER; } // Subparse global-state else if (qName.Equals("global-state")) { string id = null; foreach (KeyValuePair<string, string> entry in attrs) { if (entry.Key.Equals("id")) id = entry.Value.ToString(); } currentGlobalState = new GlobalState(id); currentString = string.Empty; chapter.addGlobalState(currentGlobalState); subParser = new ConditionSubParser(currentGlobalState, chapter); subParsing = GLOBAL_STATE; } // Subparse macro else if (qName.Equals("macro")) { string id = null; foreach (KeyValuePair<string, string> entry in attrs) { if (entry.Key.Equals("id")) id = entry.Value.ToString(); } currentMacro = new Macro(id); currentString = string.Empty; chapter.addMacro(currentMacro); subParser = new EffectSubParser(currentMacro, chapter); subParsing = MACRO; } // Subparse atrezzo object else if (qName.Equals("atrezzoobject")) { subParser = new AtrezzoSubParser(chapter); subParsing = ATREZZO; }// Subparse assessment profile else if (qName.Equals("assessment")) { subParser = new AssessmentSubParser(chapter); subParsing = ASSESSMENT; }// Subparse adaptation profile else if (qName.Equals("adaptation")) { subParser = new AdaptationSubParser(chapter); subParsing = ADAPTATION; } } // If an element is being subparsed, spread the call if (subParsing != NONE) { //try { subParser.startElement(namespaceURI, sName, qName, attrs); //} catch (Exception e) { Debug.LogError(e); }{ // System.out.println("Marihuanhell es muy malo pero hemos capturado la excepción"); //e.printStackTrace(); //} } }
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 static void G_set(LuaState L, GlobalState s) { L.l_G = s; }
private static uint PropagateAll(GlobalState g) { uint m = 0; while (g.gray != null) m += (uint)PropagateMark(g); return m; }
/** * 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); }
/* ** 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; } }