Exemplo n.º 1
0
 public override void Perform(Game _assets, Domain _environment, LCode _code, Stack <LValue> _stack)
 {
     if ((double)_stack.Pop().Value == 0)
     {
         _environment.ProgramCounter = this.Jump;
     }
 }
Exemplo n.º 2
0
        public override void Perform(Game _assets, Domain _environment, LCode _code, Stack <LValue> _stack)
        {
            switch (this.Type)
            {
            case LArgumentType.Variable: {
                if (this.Data == 0 && _stack.Count > 0)
                {
                    LValue _valPush = _stack.Pop();
                    Dictionary <string, LValue> _variableList = Helper.GetVariables(_assets, _environment, (double)_stack.Pop().Value);
                    LValue _varFind = _variableList[this.Variable.Name];
                    switch (_varFind.Type)
                    {
                    case LType.Array: {
                        _stack.Push(_varFind.Array[(int)(double)_valPush.Value]);
                        break;
                    }

                    default: {
                        throw new Exception(String.Format("Could not handle push for type: {0}", _varFind.Type));
                    }
                    }
                }
                else
                {
                    _stack.Push(Helper.GetVariables(_assets, _environment, this.Data)[this.Variable.Name]);
                }
                break;
            }

            default: {
                _stack.Push(this.Value);
                break;
            }
            }
        }
Exemplo n.º 3
0
        public override void Perform(Game _assets, Domain _environment, LCode _code, Stack <LValue> _stack)
        {
            LValue _valRight = _stack.Pop();
            LValue _valLeft  = _stack.Pop();

            _stack.Push(_valLeft / _valRight);
        }
Exemplo n.º 4
0
        public Call(Int32 _instruction, Game _game, LCode _code, BinaryReader _reader) : base(_instruction)
        {
            this.FunctionName = _game.Functions[_game.FunctionMapping[(int)((_code.Base + _reader.BaseStream.Position))]].Name;
            if (Runner.Function.Mapping.ContainsKey(this.FunctionName) == true)
            {
                this.Function = Runner.Function.Mapping[this.FunctionName];
                this.Type     = CallType.Function;
            }
            else
            {
                if (_game.Code.ContainsKey(this.FunctionName) == true)
                {
                    this.Code = _game.Code[this.FunctionName];
                    this.Type = CallType.Method;
                }
                else
                {
                    throw new Exception(String.Format("Could not find function or script named \"{0}\"", this.FunctionName));
                }
            }

            this.Count     = this.Data;
            this.Arguments = new LValue[this.Count];
            _reader.ReadInt32();
        }
Exemplo n.º 5
0
        public override void Perform(Game _assets, Domain _environment, LCode _code, Stack <LValue> _stack)
        {
            switch (this.Variable)
            {
            case "room": {
                _stack.Push(LValue.Real((double)_assets.CurrentRoom.Index));
                break;
            }

            case "room_width": {
                _stack.Push(LValue.Real((double)_assets.CurrentRoom.Width));
                break;
            }

            case "room_height": {
                _stack.Push(LValue.Real((double)_assets.CurrentRoom.Height));
                break;
            }

            case "undefined": {
                _stack.Push(LValue.Undef());
                break;
            }

            case "current_time": {
                _stack.Push(LValue.Real(VM.Timer.ElapsedMilliseconds));
                break;
            }

            default: {
                throw new Exception(String.Format("Could not return built-in variable named: \"{0}\"", this.Variable));
            }
            }
        }
Exemplo n.º 6
0
 public static void CODE(Game _assets, BinaryReader _reader, Chunk _chunk)
 {
     HandleKVP(_assets, _reader, delegate(Int32 _offset) {
         LCode _codeGet = new LCode(_assets, _reader);
         _assets.Code.Add(_codeGet.Name, _codeGet);
         _assets.CodeMapping.Add(_codeGet);
     });
 }
Exemplo n.º 7
0
 public override void Perform(Game _assets, Domain _environment, LCode _code, Stack <LValue> _stack)
 {
     for (int i = 0; i < this.Count; i++)
     {
         this.Arguments[i] = _stack.Pop();
     }
     _stack.Push(this.Function(_assets, _environment, this.Arguments, this.Count, _stack));
 }
Exemplo n.º 8
0
        public override void Perform(Game _assets, Domain _environment, LCode _code, Stack <LValue> _stack)
        {
            switch ((LArgumentType)this.Argument)
            {
            case LArgumentType.Variable: {
                _stack.Push(_assets.GlobalScope.Variables[this.Variable]);
                break;
            }

            default: {
                throw new Exception(String.Format("Could not push unimplemented global type: \"{0}\"", (LArgumentType)this.Argument));
            }
            }
        }
Exemplo n.º 9
0
        public override void Perform(Game _assets, Domain _environment, LCode _code, Stack <LValue> _stack)
        {
            LValue _valRight = _stack.Pop();
            LValue _valLeft  = _stack.Pop();

            if (_valRight.Number == 0 || _valLeft.Number == 0)
            {
                _stack.Push(_valLeft);
            }
            else
            {
                _stack.Push(LValue.Real(_valLeft.Number % _valRight.Number));
            }
        }
Exemplo n.º 10
0
        public PushGlobal(Int32 _instruction, Game _game, LCode _code, BinaryReader _reader) : base(_instruction)
        {
            switch ((LArgumentType)this.Argument)
            {
            case LArgumentType.Variable: {
                this.Variable = _game.Variables[_game.VariableMapping[(int)((_code.Base + _reader.BaseStream.Position)) - 4]].Name;
                _reader.ReadInt32();
                break;
            }

            default: {
                throw new Exception(String.Format("Could not parse unimplemented global push type: \"{0}\"", (LArgumentType)this.Argument));
            }
            }
        }
Exemplo n.º 11
0
        public Pop(Int32 _instruction, Game _game, LCode _code, BinaryReader _reader) : base(_instruction)
        {
            this.ArgTo   = (LArgumentType)(this.Argument & 0xF);
            this.ArgFrom = (LArgumentType)((this.Argument >> 4) & 0xF);
            switch (this.ArgTo)
            {
            case LArgumentType.Variable: {
                Int32 _varOffset = (int)((_code.Base + _reader.BaseStream.Position)) - 4;
                this.Variable = _game.Variables[_game.VariableMapping[_varOffset]];
                _reader.ReadInt32();
                break;
            }

            default: {
                throw new Exception(String.Format("Could not pop from {0} to {1}", this.ArgTo, this.ArgFrom));
            }
            }
        }
Exemplo n.º 12
0
        public override void Perform(Game _assets, Domain _environment, LCode _code, Stack <LValue> _stack)
        {
            double _instScope = _stack.Pop().Number;

            switch (_instScope)
            {
            case -9: {
                _instScope = _stack.Pop().Number;
                break;
            }
            }

            /*
             *  NOTE:
             *  The code here isn't great, I don't really want to do code execution this way.
             *  I think that the code should be ran in the current scope, and we'll just have a stack
             *  that holds each instance scope in it. This does work, but doesn't really follow the
             *  pattern set by Runner.exe and will likely lead to issues down the line.
             *  - Nommiin
             */
            if (_instScope >= 0 && _instScope < LInstance.IDStart)
            {
                List <LInstance> _instList = LInstance.FindList(_assets, _instScope, true);
                if (_instList != null)
                {
                    foreach (LInstance _instGet in _instList)
                    {
                        _instGet.Environment.Locals = _environment.Locals;
                        _instGet.Environment.ExecuteCode(_assets, _code, new Tuple <int, int>(_environment.ProgramCounter + 1, this.Jump));
                    }
                }
            }
            else
            {
                LInstance _instGet = _assets.InstanceMapping[_instScope];
                if (_instGet != null)
                {
                    _instGet.Environment.Locals = _environment.Locals;
                    _instGet.Environment.ExecuteCode(_assets, _code, new Tuple <int, int>(_environment.ProgramCounter + 1, this.Jump));
                }
            }
            _environment.ProgramCounter = this.Jump;
        }
Exemplo n.º 13
0
        public Push(Int32 _instruction, Game _game, LCode _code, BinaryReader _reader) : base(_instruction)
        {
            this.IsArray = false;
            this.Type    = (LArgumentType)this.Argument;
            switch (this.Type)
            {
            case LArgumentType.Error: {
                this.Value = new LValue(LType.Number, (double)this.Data);
                break;
            }

            case LArgumentType.Integer: {
                this.Value = new LValue(LType.Number, (double)_reader.ReadInt32());
                break;
            }

            case LArgumentType.Long: {
                this.Value = new LValue(LType.Number, (double)_reader.ReadInt64());
                break;
            }

            case LArgumentType.Double: {
                this.Value = new LValue(LType.Number, (double)_reader.ReadDouble());
                break;
            }

            case LArgumentType.String: {
                this.Value = new LValue(LType.String, (string)_game.StringMapping[_reader.ReadInt32()].Value);
                break;
            }

            case LArgumentType.Variable: {
                this.Variable = _game.Variables[_game.VariableMapping[(int)((_code.Base + _reader.BaseStream.Position)) - 4]];
                _reader.ReadInt32();
                break;
            }

            default: {
                throw new Exception(String.Format("Could not parse unimplemented push type {0}", this.Type));
            }
            }
        }
Exemplo n.º 14
0
        public override void Perform(Game _assets, Domain _environment, LCode _code, Stack <LValue> _stack)
        {
            LValue _compRight = _stack.Pop();
            LValue _compLeft  = _stack.Pop();

            switch (this.Type)
            {
            case LConditionType.Equal: _stack.Push(_compLeft == _compRight); break;

            case LConditionType.NotEqual: _stack.Push(_compLeft != _compRight); break;

            case LConditionType.LessThan: _stack.Push(_compLeft < _compRight); break;

            case LConditionType.GreaterThan: _stack.Push(_compLeft > _compRight); break;

            case LConditionType.LessEqual: _stack.Push(_compLeft <= _compRight); break;

            case LConditionType.GreaterEqual: _stack.Push(_compLeft >= _compRight); break;
            }
        }
Exemplo n.º 15
0
        public void ExecuteCode(Game _assets, LCode _code, Tuple <int, int> _range = null)
        {
            this.Current = _code;
            if (_range == null)
            {
                _range = new Tuple <int, int>(0, this.Current.Instructions.Count);
            }
            for (this.ProgramCounter = _range.Item1; this.ProgramCounter < _range.Item2; this.ProgramCounter++)
            {
                _code.Instructions[this.ProgramCounter].Perform(_assets, this, _code, this.Stack);
            }

#if (DEBUG)
            if (_assets.Headless == true)
            {
                Console.WriteLine("Instance Variables (Object: {0}, Count: {1})", (this.Instance.Object != null ? this.Instance.Object.Name : "N/A"), this.Instance.Variables.Count);
                foreach (KeyValuePair <string, LValue> _instVar in this.Instance.Variables)
                {
                    Console.WriteLine("{0}.{1} = {2}", this.Instance.ID, _instVar.Key, _instVar.Value.Value);
                }
            }
#endif
        }
Exemplo n.º 16
0
        public LEvent(LObject _object, Game _assets, BinaryReader _reader, LObject _owner, Int32 _type)
        {
            this.Owner         = _owner;
            this.Subtype       = _type;
            this.LibraryID     = _reader.ReadInt32();
            this.ID            = _reader.ReadInt32();
            this.Type          = (ActionType)_reader.ReadInt32();
            this.UseRelative   = _reader.ReadLBoolean();
            this.IsQuestion    = _reader.ReadLBoolean();
            this.ApplyTo       = _reader.ReadLBoolean();
            this.Execution     = (ActionExecution)_reader.ReadInt32();
            this.Name          = _assets.GetString(_reader.ReadInt32());
            this.Code          = _assets.CodeMapping[_reader.ReadInt32()];
            this.ArgumentCount = _reader.ReadInt32();
            this.Caller        = _reader.ReadInt32();
            this.IsRelative    = _reader.ReadLBoolean();
            this.IsNot         = _reader.ReadLBoolean();

            switch (this.Code.Name.Replace("gml_Object_" + _object.Name + "_", ""))
            {
            case "PreCreate_0": _object.PreCreate = this.Code; break;

            case "Create_0": _object.Create = this.Code; break;

            case "Step_1": _object.BeginStep = this.Code; break;

            case "Step_0": _object.Step = this.Code; break;

            case "Step_2": _object.EndStep = this.Code; break;

            case "Draw_0": _object.Draw = this.Code; break;

            case "Destroy_0": _object.Destroy = this.Code; break;

            case "CleanUp_0": _object.CleanUp = this.Code; break;
            }
        }
Exemplo n.º 17
0
 /// <summary>
 /// 号码后6位。
 /// </summary>
 /// <returns></returns>
 public string CodePart2()
 {
     return(LCode.Substring(6, 6));
 }
Exemplo n.º 18
0
        public LInstance(Game _assets, LObject _object, bool _include = false, double _x = 0, double _y = 0)
        {
            this.Object      = _object;
            this.ID          = LInstance.IDCount++;
            this.Environment = new Domain(this);
            this.Variables   = new Dictionary <string, LValue>()
            {
                ["x"]         = new LValue(LType.Number, _x),
                ["y"]         = new LValue(LType.Number, _y),
                ["xprevious"] = new LValue(LType.Number, _x),
                ["yprevious"] = new LValue(LType.Number, _y),
                ["xstart"]    = LValue.Real(_x),
                ["ystart"]    = LValue.Real(_y),

                ["id"]           = new LValue(LType.Number, ID),
                ["solid"]        = new LValue(LType.Number, (double)(_object.Solid ? 1 : 0)),
                ["visible"]      = new LValue(LType.Number, (double)(_object.Visible ? 1 : 0)),
                ["persistent"]   = new LValue(LType.Number, (double)(_object.Persistent ? 1 : 0)),
                ["depth"]        = new LValue(LType.Number, (double)_object.Depth),
                ["alarm"]        = LValue.Values(Enumerable.Repeat(LValue.Real(0), 8).ToArray()),//better than writing 8 LValue.Real(0)
                ["object_index"] = new LValue(LType.Number, (double)_object.Index),

                ["sprite_index"]   = new LValue(LType.Number, (double)(_object.Sprite != null ? _object.Sprite.Index : -1)),
                ["sprite_width"]   = new LValue(LType.Number, (double)(_object.Sprite != null ? _object.Sprite.Width : 0)),
                ["sprite_height"]  = new LValue(LType.Number, (double)(_object.Sprite != null ? _object.Sprite.Height : 0)),
                ["sprite_xoffset"] = new LValue(LType.Number, (double)(_object.Sprite != null ? _object.Sprite.XOrigin : 0)),
                ["sprite_yoffset"] = new LValue(LType.Number, (double)(_object.Sprite != null ? _object.Sprite.YOrigin : 0)),
                ["image_alpha"]    = new LValue(LType.Number, (double)1),
                ["image_angle"]    = new LValue(LType.Number, (double)30),
                ["image_blend"]    = new LValue(LType.Number, (double)0xFFFFFF),
                ["image_index"]    = new LValue(LType.Number, (double)0),
                ["image_number"]   = new LValue(LType.Number, (double)(_object.Sprite != null ? _object.Sprite.FrameCount : 0)),
                ["image_speed"]    = new LValue(LType.Number, (double)(_object.Sprite != null ? _object.Sprite.PlaybackSpeed : 1)),
                ["image_xscale"]   = new LValue(LType.Number, (double)1),
                ["image_yscale"]   = new LValue(LType.Number, (double)1),

                ["mask_index"]  = new LValue(LType.Number, (double)(_object.Mask != null ? _object.Mask.Index : -1)),
                ["bbox_left"]   = new LValue(LType.Number, _object.Mask != null ? _x + _object.Mask.BoundsLeft : _x),
                ["bbox_right"]  = new LValue(LType.Number, _object.Mask != null ? _x + _object.Mask.BoundsRight : _x),
                ["bbox_top"]    = new LValue(LType.Number, _object.Mask != null ? _y + _object.Mask.BoundsTop : _y),
                ["bbox_bottom"] = new LValue(LType.Number, _object.Mask != null ? _y + _object.Mask.BoundsBottom : _y),
            };

            if (_include == true)
            {
                _assets.InstanceList.Add(this);
                _assets.InstanceMapping[this.ID] = this;
                if (_assets.ObjectInstances.ContainsKey(this.Object.Index) == false)
                {
                    _assets.ObjectInstances[this.Object.Index] = new List <LInstance>();
                }
                _assets.ObjectInstances[this.Object.Index].Add(this);
            }

            this.PreCreate = _object.PreCreate;
            this.Create    = _object.Create;
            this.BeginStep = _object.BeginStep;
            this.Step      = _object.Step;
            this.EndStep   = _object.EndStep;
            this.Draw      = _object.Draw;
            this.Destroy   = _object.Destroy;
            this.CleanUp   = _object.CleanUp;
        }
Exemplo n.º 19
0
 public Exit(Int32 _instruction, Game _game, LCode _code, BinaryReader _reader) : base(_instruction)
 {
 }
Exemplo n.º 20
0
 public override void Perform(Game _assets, Domain _environment, LCode _code, Stack <LValue> _stack)
 {
 }
Exemplo n.º 21
0
 public PopEnvironment(Int32 _instruction, Game _game, LCode _code, BinaryReader _reader) : base(_instruction)
 {
     this.Offset = (Int32)((_reader.BaseStream.Position + (this.Raw << 9 >> 7)) - 4);
 }
Exemplo n.º 22
0
 public override void Perform(Game _assets, Domain _environment, LCode _code, Stack <LValue> _stack)
 {
     Console.WriteLine("Stack Size: {0}", _stack.Count);
     throw new Exception("");
 }
Exemplo n.º 23
0
 public PushImmediate(Int32 _instruction, Game _game, LCode _code, BinaryReader _reader) : base(_instruction)
 {
     this.Value = new LValue(LType.Number, (double)this.Data);
 }
Exemplo n.º 24
0
 public virtual void Perform(Game _assets, Domain _environment, LCode _code, Stack <LValue> _stack)
 {
     Console.WriteLine("[WARNING] - Could not perform action for unimplemented opcode: {0} in {1}", this.Opcode, _code.Name);
 }
Exemplo n.º 25
0
 public PushLocal(Int32 _instruction, Game _game, LCode _code, BinaryReader _reader) : base(_instruction)
 {
     this.Variable = _game.Variables[_game.VariableMapping[(int)((_code.Base + _reader.BaseStream.Position)) - 4]].Name;
     _reader.ReadInt32();
 }
Exemplo n.º 26
0
        public override void Perform(Game _assets, Domain _environment, LCode _code, Stack <LValue> _stack)
        {
            if (_environment.ArrayNext == true)
            {
                int _arrayIndex = (int)(double)_stack.Pop().Value;
                Dictionary <string, LValue> _variableList = Helper.GetVariables(_assets, _environment, (double)_stack.Pop().Value);

                if (_variableList.ContainsKey(this.Variable.Name) == false || _variableList[this.Variable.Name].Type != LType.Array)
                {
                    _variableList[this.Variable.Name] = new LValue(LType.Array, new LValue[_arrayIndex + 1]);
                    for (int i = 0; i <= _arrayIndex; i++)
                    {
                        _variableList[this.Variable.Name].Array[i] = new LValue(LType.Number, (double)0);
                    }
                }

                LValue _valGet = _variableList[this.Variable.Name];
                if (_arrayIndex > _valGet.Array.Length)
                {
                    LValue _valCopy = new LValue(LType.Array, new LValue[_arrayIndex + 1]);
                    for (int i = 0; i <= _arrayIndex; i++)
                    {
                        if (i < _valGet.Array.Length)
                        {
                            _valCopy.Array[i] = _valGet.Array[i];
                        }
                        else
                        {
                            _valCopy.Array[i] = new LValue(LType.Number, (double)0);
                        }
                    }
                    _variableList[this.Variable.Name] = _valCopy;
                    _valGet = _valCopy;
                }
                _valGet.Array[_arrayIndex] = _stack.Pop();
                _environment.ArrayNext     = false;
            }
            else
            {
                double _varScope = this.Data;
                if (this.Data == 0 && _stack.Count > 1)
                {
                    switch ((double)_stack.Pop())
                    {
                    case -9: {
                        _varScope = _stack.Pop();
                        break;
                    }
                    }
                }

                if (_varScope >= 0 && _varScope < LInstance.IDStart)
                {
                    LValue           _valSet   = _stack.Pop();
                    List <LInstance> _instList = LInstance.FindList(_assets, _varScope, true);
                    if (_instList != null)
                    {
                        foreach (LInstance _instGet in _instList)
                        {
                            _instGet.Variables[this.Variable.Name] = _valSet;
                        }
                    }
                }
                else
                {
                    Helper.GetVariables(_assets, _environment, _varScope)[this.Variable.Name] = _stack.Pop();
                }
            }
        }
Exemplo n.º 27
0
 public BranchFalse(Int32 _instruction, Game _game, LCode _code, BinaryReader _reader) : base(_instruction, _game, _code, _reader)
 {
 }
Exemplo n.º 28
0
 /// <summary>
 /// 号码前6位。
 /// </summary>
 /// <returns></returns>
 public string CodePart1()
 {
     return(LCode.Substring(0, 6));
 }
Exemplo n.º 29
0
 public Conditional(Int32 _instruction, Game _game, LCode _code, BinaryReader _reader) : base(_instruction)
 {
     this.Type = (LConditionType)((this.Data >> 8) & 0xFF);
 }