コード例 #1
0
        /// <summary>
        /// Divides the value stored in the local variable by the specified float value.
        /// </summary>
        /// <param name="Args">A ScriptArguments instance.</param>
        public static void DivFloatLVarByVal(ref ScriptArguments Args)
        {
            SCMOpcodeParameter FirstParam = Args[0];

            FirstParam.Real /= Args[1].Real;
            Args[0]          = FirstParam; //This should work, in theory.
        }
コード例 #2
0
        /// <summary>
        /// Divides the value stored in the local variable by the specified integer value.
        /// </summary>
        /// <param name="Args">A ScriptArguments instance.</param>
        public static void DivIntLVarByVal(ref ScriptArguments Args)
        {
            SCMOpcodeParameter FirstParam = Args[0];

            FirstParam.Integer += Args[1].Integer;
            Args[0]             = FirstParam; //This should work, in theory.
        }
コード例 #3
0
        /// <summary>
        /// Multiplies the value stored in the global variable by the specified float value.
        /// </summary>
        /// <param name="Args">A ScriptArguments instance.</param>
        public static void MultFloatVarByVal(ref ScriptArguments Args)
        {
            SCMOpcodeParameter FirstParam = Args[0];

            FirstParam.GlobalReal *= Args[1].Real;
            Args[0] = FirstParam; //This should work, in theory.
        }
コード例 #4
0
        /// <summary>
        /// Multiplies the value stored in the global variable by the specified integer value.
        /// </summary>
        /// <param name="Args">A ScriptArguments instance.</param>
        public static void MultIntVarByVal(ref ScriptArguments Args)
        {
            SCMOpcodeParameter FirstParam = Args[0];

            FirstParam.GlobalInteger *= Args[1].Integer;
            Args[0] = FirstParam; //This should work, in theory.
        }
コード例 #5
0
        /// <summary>
        /// Increases the value stored in the local variable by the specified float value.
        /// </summary>
        /// <param name="Args">A ScriptArguments instance.</param>
        public static void AddValToFloatLVar(ref ScriptArguments Args)
        {
            SCMOpcodeParameter FirstParam = Args[0];

            FirstParam.GlobalReal += Args[1].Real;
            Args[0] = FirstParam; //This should work, in theory.
        }
コード例 #6
0
ファイル: ScriptFunctions.cs プロジェクト: xWhitey/openvice
        /// <summary>
        /// Assigns the value of arg1 to arg2.
        /// </summary>
        /// <param name="Args">A ScriptArguments instance.</param>
        public static void FloatLeftDivisionAssignment(ref ScriptArguments Args)
        {
            var Params = Args.GetParameters();
            SCMOpcodeParameter FirstParam = Params[0];

            FirstParam.Real /= Args[0].Real;
            Params[0]        = FirstParam;
        }
コード例 #7
0
ファイル: ScriptFunctions.cs プロジェクト: xWhitey/openvice
        /// <summary>
        /// Assigns the value of arg1 to arg2.
        /// </summary>
        /// <param name="Args">A ScriptArguments instance.</param>
        public static void IntLeftDivisionAssignment(ref ScriptArguments Args)
        {
            var Params = Args.GetParameters();
            SCMOpcodeParameter FirstParam = Params[0];

            FirstParam.Integer /= Args[0].Integer;
            Params[0]           = FirstParam;
        }
コード例 #8
0
ファイル: ScriptFunctions.cs プロジェクト: xWhitey/openvice
        /// <summary>
        /// Assigns the value of arg1 to arg2.
        /// </summary>
        /// <param name="Args">A ScriptArguments instance.</param>
        public static void FloatRightMultiplicationAssignment(ref ScriptArguments Args)
        {
            var Params = Args.GetParameters();
            SCMOpcodeParameter SecondParam = Params[1];

            SecondParam.Real *= Args[0].Real;
            Params[1]         = SecondParam;
        }
コード例 #9
0
ファイル: ScriptFunctions.cs プロジェクト: xWhitey/openvice
        /// <summary>
        /// Assigns the value of arg1 to arg2.
        /// </summary>
        /// <param name="Args">A ScriptArguments instance.</param>
        public static void IntRightSubtractionAssignment(ref ScriptArguments Args)
        {
            var Params = Args.GetParameters();
            SCMOpcodeParameter SecondParam = Params[1];

            SecondParam.Integer -= Args[0].Integer;
            Params[1]            = SecondParam;
        }
コード例 #10
0
ファイル: ScriptFunctions.cs プロジェクト: xWhitey/openvice
        /// <summary>
        /// Assigns the value of arg1 to arg2.
        /// </summary>
        /// <param name="Args">A ScriptArguments instance.</param>
        public static void FloatRightDivisionAssignment(ref ScriptArguments Args)
        {
            var Params = Args.GetParameters();
            SCMOpcodeParameter SecondParam = Params[1];

            //I'm assuming the assignment happens right to left here, as that is default for C++.
            SecondParam.Real /= Args[0].Real;
            Params[1]         = SecondParam;
        }
コード例 #11
0
ファイル: ScriptFunctions.cs プロジェクト: xWhitey/openvice
        /// <summary>
        /// Assigns the value of arg1 to arg2.
        /// </summary>
        /// <param name="Args">A ScriptArguments instance.</param>
        public static void IntRightAssignment(ref ScriptArguments Args)
        {
            var Params = Args.GetParameters();
            SCMOpcodeParameter SecondParam = Params[1];

            //I'm assuming the assignment happens right to left here, as that is default for C++.
            SecondParam.Integer = Args[0].Integer;
            Params[1]           = SecondParam;
        }
コード例 #12
0
        /// <summary>
        /// Checks if the floating-point value stored in the global variable is
        /// greater than the floating-point value stored in the global variable.
        /// </summary>
        /// <param name="Args">A ScriptArguments instance.</param>
        /// <returns></returns>
        public static bool IsFloatVarGreaterThanFloatVar(ref ScriptArguments Args)
        {
            SCMOpcodeParameter FirstParam = Args[0];

            if (Args[1].Integer > FirstParam.GlobalInteger)
            {
                return(true);
            }

            return(false);
        }
コード例 #13
0
        /// <summary>
        //  Checks if the floating-point number is greater than the value stored in the local variable.
        /// </summary>
        /// <param name="Args">A ScriptArguments instance.</param>
        /// <returns>True if greater than, false otherwise.</returns>
        public static bool IsNumberGreaterThanFloatLVar(ref ScriptArguments Args)
        {
            SCMOpcodeParameter FirstParam = Args[0];

            if (Args[1].Real > FirstParam.Real)
            {
                return(true);
            }

            return(false);
        }
コード例 #14
0
        /// <summary>
        /// Checks if the integer value stored in the local variable is greater than the integer number.
        /// </summary>
        /// <param name="Args">A ScriptArguments instance.</param>
        /// <returns></returns>
        public static bool IsIntLVarGreaterThanNumber(ref ScriptArguments Args)
        {
            SCMOpcodeParameter FirstParam = Args[0];

            if (FirstParam.Integer > Args[1].Integer)
            {
                return(true);
            }

            return(false);
        }
コード例 #15
0
        /// <summary>
        /// Sets the value of a global variable to a specified integer.
        /// </summary>
        /// <param name="Args">A ScriptArguments instance.</param>
        public static void SetVarInt(ref ScriptArguments Args)
        {
            /*var Params = Args.GetParameters();
             * SCMOpcodeParameter SecondParam = Params[1];
             *
             * //I'm assuming the assignment happens right to left here, as that is default for C++.
             * SecondParam.Integer = Args[0].Integer;
             * Params[1] = SecondParam;*/

            SCMOpcodeParameter FirstParam = Args[0];

            FirstParam.GlobalInteger = Args[1].Integer;
            Args[0] = FirstParam; //This should work, in theory.
        }
コード例 #16
0
ファイル: ScriptMachine.cs プロジェクト: ammar629/openvice
        private void ExecuteThread(SCMThread Thread, int MSPassed)
        {
            ///TODO: Fully implement this.

            /*auto player = state->world->getPlayer();
             *
             * if (player)
             * {*/
            if (Thread.IsMission && Thread.DeathOrArrestCheck /*&&
                                                               * (player->isWasted() || player->isBusted())*/)
            {
                Thread.WastedOrBusted = true;
                Thread.StackDepth     = 0;
                Thread.ProgramCounter = Thread.Calls[(int)Thread.StackDepth];
            }
            //}

            // There is 02a1 opcode that is used only during "Kingdom Come", which
            // basically acts like a wait command, but waiting time can be skipped
            // by pressing 'X'? PS2 button
            if (Thread.AllowWaitSkip /*&& getState()->input[0].pressed(GameInputState::Jump)*/)
            {
                Thread.WakeCounter   = 0;
                Thread.AllowWaitSkip = false;
            }
            if (Thread.WakeCounter > 0)
            {
                Thread.WakeCounter = Math.Max(Thread.WakeCounter - MSPassed, 0);
            }
            if (Thread.WakeCounter > 0)
            {
                return;
            }

            while (Thread.WakeCounter == 0)
            {
                var PC     = Thread.ProgramCounter;
                var Opcode = file.Read <ushort>(PC);

                bool IsNegatedConditional = ((Opcode & SCM_NEGATE_CONDITIONAL_MASK) ==
                                             SCM_NEGATE_CONDITIONAL_MASK);
                Opcode = (ushort)(Opcode & ~SCM_NEGATE_CONDITIONAL_MASK);

                ScriptFunctionMeta FoundCode;
                if (!module.FindOpcode(Opcode, out FoundCode))
                {
                    throw new IllegalInstruction <Exception>(Opcode, PC, Thread.Name);
                }

                ScriptFunctionMeta Code = FoundCode;

                PC += sizeof(ushort);

                List <SCMOpcodeParameter> Parameters = new List <SCMOpcodeParameter>();

                bool HasExtraParameters = Code.Arguments < 0;
                var  RequiredParams     = Math.Abs(Code.Arguments);

                for (int p = 0; p < RequiredParams || HasExtraParameters; ++p)
                {
                    //byte was originally SCMByte ... might have to change to char.
                    var type_r = file.Read <byte>(PC);
                    var type   = (SCMType)type_r;

                    if (type_r > 42)
                    {
                        // for implicit strings, we need the byte we just read.
                        type = SCMType.TString;
                    }
                    else
                    {
                        PC += sizeof(byte);
                    }

                    //TODO: Is this correct?
                    //Parameters.push_back(SCMOpcodeParameter{ type, { 0} });
                    Parameters.Add(new SCMOpcodeParameter(type));

                    switch (type)
                    {
                    case SCMType.EndOfArgList:
                        HasExtraParameters = false;
                        break;

                    case SCMType.TInt8:
                        lock (Parameters)     //Thread safety
                        {
                            SCMOpcodeParameter Param = Parameters.LastOrDefault();
                            Param.Integer = file.Read <byte>(PC);
                            Parameters[Parameters.Count - 1] = Param;
                        }
                        PC += sizeof(byte);
                        break;

                    case SCMType.TInt16:
                        lock (Parameters)     //Thread safety
                        {
                            SCMOpcodeParameter Param = Parameters.LastOrDefault();
                            Param.Integer = file.Read <short>(PC);
                            Parameters[Parameters.Count - 1] = Param;
                        }
                        PC += sizeof(byte) * 2;
                        break;

                    case SCMType.TGlobal:
                    {
                        var v = file.Read <ushort>(PC);

                        lock (Parameters)         //Thread safety
                        {
                            SCMOpcodeParameter Param = Parameters.LastOrDefault();
                            //TODO: This was originally GlobalData.data() + v...
                            Param.GlobalPtr = (IntPtr)globalData.ToArray().Length + v * SCM_VARIABLE_SIZE;
                            Parameters[Parameters.Count - 1] = Param;
                        }

                        if (v >= file.GlobalsSize)
                        {
                            Debug.WriteLine("ERROR: ScriptMachine.cs: Global out of bounds! " +
                                            v.ToString() + " " +
                                            file.GlobalsSize.ToString());
                        }
                        PC += sizeof(byte) * 2;
                    }
                    break;

                    case SCMType.TLocal:
                    {
                        var v = file.Read <ushort>(PC);

                        lock (Parameters)
                        {
                            SCMOpcodeParameter Param = Parameters.LastOrDefault();
                            //Not sure if this is correct, was originally Locals.data() + v...
                            Param.GlobalPtr = (IntPtr)Thread.Locals.ToArray().Length + v * SCM_VARIABLE_SIZE;
                            Parameters[Parameters.Count - 1] = Param;
                        }

                        if (v >= SCM_THREAD_LOCAL_SIZE)
                        {
                            Debug.WriteLine("Scriptmachine.CS: Local out of bounds!");
                        }
                        PC += sizeof(byte) * 2;
                    }
                    break;

                    case SCMType.TInt32:
                        lock (Parameters)     //Thread safety
                        {
                            SCMOpcodeParameter Param = Parameters.LastOrDefault();
                            Param.Integer = file.Read <int>(PC);
                            Parameters[Parameters.Count - 1] = Param;
                        }
                        PC += sizeof(byte) * 4;
                        break;

                    case SCMType.TString:
                        lock (Parameters)     //Thread safety
                        {
                            SCMOpcodeParameter Param = Parameters.LastOrDefault();
                            char[]             Str   = Param.Str.ToArray();
                            //Copy a string from the file data to the string.
                            Array.Copy(file.Data.ToArray(), (int)PC, Str, 0, 8);
                            Param.Str = new string(Str);
                            Parameters[Parameters.Count - 1] = Param;
                        }

                        PC += sizeof(byte) * 8;
                        break;

                    case SCMType.TFloat16:
                        lock (Parameters)     //Thread safety
                        {
                            SCMOpcodeParameter Param = Parameters.LastOrDefault();
                            Param.Real = file.Read <short>(PC) / 16f;
                            Parameters[Parameters.Count - 1] = Param;
                        }
                        PC += sizeof(byte) * 2;
                        break;

                    default:
                        throw new UnknownType <Exception>((char)type, PC, Thread.Name);
                    }
                    ;

                    ScriptArguments Sca = new ScriptArguments(Parameters, Thread, this);