Пример #1
0
        public LocalDeleteFrame(AVSValue args, ScriptEnvironment env)
            : base(args, env)
        {
            vi = GetVideoInfo();
            int[] skips = GetSkipFrames(args, env);

            List<int> f = new List<int>();

            int length = vi.num_frames;
            int skipIdx = 0;
            for (int i = 0; i < length; i++)
            {
                if (skips[skipIdx] == i)
                {
                    skipIdx++;
                    if (skips.Length <= skipIdx)
                    {
                        skipIdx = 0;
                    }

                    vi.num_frames--;
                    continue;
                }
                f.Add(i);
            }
            this.frames = f.ToArray();
            SetVideoInfo(ref vi);
        }
Пример #2
0
        public override void Execute(ScriptEnvironment env)
        {
            Object obj = null;
            Type type = null;

            if(!IsIntermediate)
            {
                ArgumentCount = (int)env.Pop();
                Method = (string)env.Pop();
            }

            if (IsStatic)
            {
                type = (Type)env.Pop();
            }
            else
            {
                obj = env.Pop();
                type = obj.GetType();
            }
            var args = new object[ArgumentCount];
            for (var i = 0; i < args.Length; i++)
            {
                args[i] = env.Pop();
            }
            var allMethods = type.GetMethods();
            var methods = GetInvokableMethods(allMethods, Method, GetTypes(args));
            var method = methods.First();
            var ret = method.Invoke(obj, args);
            if (method.ReturnType != typeof(void))
            {
                env.Push(ret);
            }
        }
Пример #3
0
            public void ShouldSetScriptEnvironment()
            {
                var environment = new ScriptEnvironment(new string[0]);
                var scriptHost = new ScriptHost(new Mock<IScriptPackManager>().Object, environment);

                scriptHost.Env.ShouldEqual(environment);
            }
Пример #4
0
            public void ShouldSetScriptEnvironment()
            {
                var environment = new ScriptEnvironment(new string[0]);
                var scriptHost = new ScriptHost(null, environment);

                scriptHost.Env.ShouldEqual(environment);
            }
Пример #5
0
        protected override int[] GetSkipFrames(AVSValue args, ScriptEnvironment env)
        {
            Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US");
            string filename = args[1].AsString();
            HashSet<int> f = new HashSet<int>();
            int lineNo = 0;
            string line = "xx";
            try
            {
                using (StreamReader sr = new StreamReader(filename))
                {
                    while ((line = sr.ReadLine()) != null)
                    {
                        lineNo++;
                        f.Add(int.Parse(line));
                    }
                }
            }
            catch (Exception ex)
            {
                env.ThrowError(string.Format("line: {0:4} | {1} {2}\n", lineNo, ex.Message, line));
            }

            return f.Distinct().OrderBy(key => key).ToArray<int>();
        }
Пример #6
0
        public override void Execute(ScriptEnvironment env)
        {
            Type type = null;
            if(!IsIntermediate)
            {
                if (!UseDefaulConstructor)
                {
                    ArgumentCount = (int)env.Pop();
                }
                type = (Type)env.Pop();
            }
            else
            {
                type = TypeOf.GetType(TypeName);
            }

            var args = new object[ArgumentCount];
            for (var i = 0; i < args.Length; i++)
            {
                args[i] = env.Pop();
            }

            var obj = Activator.CreateInstance(type, args);
            env.Push(obj);
        }
Пример #7
0
        public override void Execute(ScriptEnvironment env)
        {
            var v1 = env.Pop();
            var v2 = env.Pop();

            env.Push(v1);
            env.Push(v2);
        }
Пример #8
0
 public override void Execute(ScriptEnvironment env)
 {
     var val = env.Pop();
     if((bool)val)
     {
         env.JumpToLabel(Name);
     }
 }
Пример #9
0
 public override void Execute(ScriptEnvironment env)
 {
     if(!IsVoid)
     {
         env.ReturnValue = env.Pop();
     }
     env.IsReturning = true;
 }
Пример #10
0
 public override void Execute(ScriptEnvironment env)
 {
     var args = new object[ArgumentCount];
     for (var i = 0; i < args.Length; i++)
     {
         args[i] = env.Pop();
     }
     env.Push(Operate(args));
 }
Пример #11
0
        public override void Execute(ScriptEnvironment env)
        {
            var obj = env.Pop();
            if(Peek)
            {
                env.Push(obj);
            }

            env.Push(obj == null);
        }
Пример #12
0
        public override void Execute(ScriptEnvironment env)
        {
            var name = TypeName;
            if(!IsIntermediate)
            {
                name = (string)env.Pop();
            }

            var type = GetType(name);
            env.Push(type);
        }
 public override void Execute(ScriptEnvironment env)
 {
     var robot = env.SpecialArgument as Robot;
     if (robot.Cooldown == 0)
     {
         Execute(env, robot);
     }
     else
     {
         robot.Cooldown--;
         env.ProgramCounter--;
     }
 }
Пример #14
0
        public override void Execute(ScriptEnvironment env)
        {
            var newEnv = env.Split();

            var args = new object[ArgumentCount];
            for (var i = 0; i < ArgumentCount; i++)
            {
                args[i] = env.Pop();
            }
            for(var i = ArgumentCount - 1; i >= 0; i--)
            {
                newEnv.Push(args[i]);
            }

            newEnv.JumpToLabel(Label);
            newEnv.ProgramCounter++;
            var exec = new ScriptExecution(newEnv);
            env.ExecutionManager.Add(exec);
        }
Пример #15
0
 private ScriptTestRunner()
 {
     _scriptEnvironment = ScriptEnvironment.Default;
 }
Пример #16
0
 public ScriptPackagesTests(ITestOutputHelper testOutputHelper)
 {
     testOutputHelper.Capture();
     _scriptEnvironment = ScriptEnvironment.Default;
 }
Пример #17
0
 public ScriptPublisherTests(ITestOutputHelper testOutputHelper)
 {
     testOutputHelper.Capture();
     _scriptEnvironment = ScriptEnvironment.Default;
     _commandRunner     = new CommandRunner(GetLogFactory());
 }
Пример #18
0
 public CompilationDependencyResolverTests(ITestOutputHelper testOutputHelper)
 {
     testOutputHelper.Capture();
     _scriptEnvironment = ScriptEnvironment.Default;
 }
 public ScriptParserTests(ITestOutputHelper testOutputHelper)
 {
     testOutputHelper.Capture(minimumLogLevel: 0);
     _scriptEnvironment = ScriptEnvironment.Default;
 }
Пример #20
0
 public override void Execute(ScriptEnvironment env)
 {
     action(env);
 }
 private RuntimeDependencyResolver(ScriptProjectProvider scriptProjectProvider, ScriptDependencyInfoProvider scriptDependencyInfoProvider, ScriptFilesDependencyResolver scriptFilesDependencyResolver, LogFactory logFactory, ScriptEnvironment scriptEnvironment, bool useRestoreCache)
 {
     _scriptProjectProvider         = scriptProjectProvider;
     _scriptDependencyInfoProvider  = scriptDependencyInfoProvider;
     _scriptFilesDependencyResolver = scriptFilesDependencyResolver;
     _logger            = logFactory.CreateLogger <RuntimeDependencyResolver>();
     _scriptEnvironment = scriptEnvironment;
     _runtimeMatcher    = new Regex($"{_scriptEnvironment.PlatformIdentifier}.*-{_scriptEnvironment.ProccessorArchitecture}");
 }
 public ScriptPackagesFixture()
 {
     _scriptEnvironment = ScriptEnvironment.Default;
     ClearGlobalPackagesFolder();
     BuildScriptPackages();
 }
Пример #23
0
 public override void Execute(ScriptEnvironment env)
 {
     throw new Exception();
 }
Пример #24
0
 public override AVSValue ExecuteAfter(AVSValue clip, ScriptEnvironment env)
 {
     return(env.Invoke("FlipVertical", new AVSValue(clip)));
 }
Пример #25
0
 public override void Execute(ScriptEnvironment env)
 {
     var pc = (int)env.CallPop();
     env.ProgramCounter = pc;
 }
Пример #26
0
 public ScriptParserTests(ITestOutputHelper testOutputHelper)
 {
     _testOutputHelper  = testOutputHelper;
     _scriptEnvironment = ScriptEnvironment.Default;
 }
Пример #27
0
 public override void Execute(ScriptEnvironment env)
 {
     env[Name] = env.Pop();
 }
Пример #28
0
 /// <summary>
 /// Initializes a new instance of the <see cref="EnvironmentReporter"/> class.
 /// </summary>
 /// <param name="versionProvider">The <see cref="IVersionProvider"/> that is
 /// responsible for providing the current and latest version.</param>
 /// <param name="scriptConsole">The <see cref="ScriptConsole"/> to write to.</param>
 /// <param name="scriptEnvironment">The <see cref="ScriptEnvironment"/> providing environmental information.</param>
 public EnvironmentReporter(IVersionProvider versionProvider, ScriptConsole scriptConsole, ScriptEnvironment scriptEnvironment)
 {
     _versionProvider   = versionProvider;
     _scriptConsole     = scriptConsole;
     _scriptEnvironment = scriptEnvironment;
 }
 public RuntimeDependencyResolver(ScriptProjectProvider scriptProjectProvider, LogFactory logFactory, ScriptEnvironment scriptEnvironment, bool useRestoreCache)
 {
     _scriptProjectProvider   = scriptProjectProvider;
     _scriptEnvironment       = scriptEnvironment;
     _dependencyContextReader = new ScriptDependencyContextReader(logFactory);
     _restorer = CreateRestorer(logFactory, useRestoreCache);
 }
 public ScriptPublisherTests()
 {
     _scriptEnvironment = ScriptEnvironment.Default;
     _commandRunner     = new CommandRunner(GetLogFactory());
 }
Пример #31
0
 public override void Execute(ScriptEnvironment env)
 {
     env.Push(env[Variable]);
 }
Пример #32
0
 public override void Execute(ScriptEnvironment env)
 {
     env.Push(env[Argument]);
 }
Пример #33
0
 public override void Execute(ScriptEnvironment env)
 {
 }
Пример #34
0
 public ScaffoldingTests()
 {
     _scriptEnvironment = ScriptEnvironment.Default;
 }
Пример #35
0
        public override VideoFrame GetFrame(int n, ScriptEnvironment env)
        {
            if (noRotate)
            {
                return(base.GetFrame(n, env));
            }
            var res   = NewVideoFrame(env);
            var frame = Child.GetFrame(n, env);
            var vi    = Child.GetVideoInfo();

            Parallel.ForEach(planes, plane =>
            {
                var zero = plane == YUVPlanes.PLANAR_U || plane == YUVPlanes.PLANAR_V ? 128 : 0;
                OverlayUtils.MemSet(res.GetWritePtr(plane), zero, res.GetPitch(plane) * res.GetHeight(plane));

                // get source image size
                var height     = frame.GetHeight(plane);
                var width      = vi.width / (vi.height / height);
                var oldXradius = (width - 1) / 2.0;
                var oldYradius = (height - 1) / 2.0;
                var pixelSize  = frame.GetRowSize(plane) / width;

                // get destination image size
                var newWidth   = GetVideoInfo().width;
                var newHeight  = GetVideoInfo().height;
                var newXradius = (newWidth - 1) / 2.0;
                var newYradius = (newHeight - 1) / 2.0;

                // angle's sine and cosine
                var angleRad = -angle * Math.PI / 180;
                var angleCos = Cos(angleRad);
                var angleSin = Sin(angleRad);

                var ymax = height - 1;
                var xmax = width - 1;

                var srcStride = frame.GetPitch(plane);
                var dstOffset = res.GetPitch(plane) - res.GetRowSize(plane);

                unsafe
                {
                    var src = (byte *)frame.GetReadPtr(plane);
                    var dst = (byte *)res.GetWritePtr(plane);

                    var cy = -newYradius;
                    for (int y = 0; y < newHeight; y++, cy++)
                    {
                        // do some pre-calculations of source points' coordinates
                        // (calculate the part which depends on y-loop, but does not
                        // depend on x-loop)
                        var tx = angleSin * cy + oldXradius;
                        var ty = angleCos * cy + oldYradius;

                        var cx = -newXradius;
                        for (int x = 0; x < newWidth; x++, dst += pixelSize, cx++)
                        {
                            // coordinates of source point
                            var ox = tx + angleCos * cx;
                            var oy = ty - angleSin * cx;

                            // top-left coordinate
                            var ox1 = (int)ox;
                            var oy1 = (int)oy;

                            // validate source pixel's coordinates
                            if (ox1 >= 0 && oy1 >= 0 && ox1 < width && oy1 < height)
                            {
                                // bottom-right coordinate
                                var ox2 = ox1 == xmax ? ox1 : ox1 + 1;
                                var oy2 = oy1 == ymax ? oy1 : oy1 + 1;

                                var dx1 = ox - ox1;
                                if (dx1 < 0)
                                {
                                    dx1 = 0;
                                }
                                var dx2 = 1.0f - dx1;

                                var dy1 = oy - oy1;
                                if (dy1 < 0)
                                {
                                    dy1 = 0;
                                }
                                var dy2 = 1.0f - dy1;

                                // get four points
                                byte *p1, p2;
                                p1  = p2 = src + oy1 * srcStride;
                                p1 += ox1 * pixelSize;
                                p2 += ox2 * pixelSize;

                                byte *p3, p4;
                                p3  = p4 = src + oy2 * srcStride;
                                p3 += ox1 * pixelSize;
                                p4 += ox2 * pixelSize;

                                // interpolate using 4 points

                                for (var z = 0; z < pixelSize; z++)
                                {
                                    dst[z] = (byte)(
                                        dy2 * (dx2 * p1[z] + dx1 * p2[z]) +
                                        dy1 * (dx2 * p3[z] + dx1 * p4[z]));
                                }
                            }
                        }
                        dst += dstOffset;
                    }
                }
            });
            return(res);
        }
Пример #36
0
 public PvcScriptHost(IScriptPackManager scriptPackManager, ScriptEnvironment environment)
     : base(scriptPackManager, environment)
 {
 }
Пример #37
0
 public DotnetRestorer(CommandRunner commandRunner, LogFactory logFactory)
 {
     _commandRunner     = commandRunner;
     _logger            = logFactory.CreateLogger <DotnetRestorer>();
     _scriptEnvironment = ScriptEnvironment.Default;
 }
Пример #38
0
 public Scaffolder(ScriptLogger logger)
 {
     _scriptEnvironment = ScriptEnvironment.Default;
     _logger            = logger;
 }
Пример #39
0
        public void Execute(ScriptContext context, System.Windows.Window window, ScriptEnvironment environment)
        {
            // Retrieve the count of plans displayed in Scope Window
            int scopePlanCount = context.PlansInScope.Count();

            if (scopePlanCount == 0)
            {
                MessageBox.Show("Scope Window does not contain any plans.");
                return;
            }

            // Retrieve names for different types of plans
            List <string> externalPlanIds = new List <string>();
            List <string> brachyPlanIds   = new List <string>();
            List <string> protonPlanIds   = new List <string>();

            foreach (var ps in context.PlansInScope)
            {
                if (ps is BrachyPlanSetup)
                {
                    brachyPlanIds.Add(ps.Id);
                }
                else if (ps is IonPlanSetup)
                {
                    protonPlanIds.Add(ps.Id);
                }
                else
                {
                    externalPlanIds.Add(ps.Id);
                }
            }

            // Construct output message
            string message = string.Format("Hello {0}, the number of plans in Scope Window is {1}.",
                                           context.CurrentUser.Name,
                                           scopePlanCount);

            if (externalPlanIds.Count > 0)
            {
                message += string.Format("\nPlan(s) {0} are external beam plans.", string.Join(", ", externalPlanIds));
            }
            if (brachyPlanIds.Count > 0)
            {
                message += string.Format("\nPlan(s) {0} are brachytherapy plans.", string.Join(", ", brachyPlanIds));
            }
            if (protonPlanIds.Count > 0)
            {
                message += string.Format("\nPlan(s) {0} are proton plans.", string.Join(", ", protonPlanIds));
            }

            // Display additional information. Use the active plan if available.
            PlanSetup plan = context.PlanSetup != null ? context.PlanSetup : context.PlansInScope.ElementAt(0);

            message += string.Format("\n\nAdditional details for plan {0}:", plan.Id);
            // TODO Show fraction message
            message += string.Format("Number of fractions : {0}\n", plan.NumberOfFractions);
            message += string.Format("Dose per fraction : {0}\n", plan.PlannedDosePerFraction.ToString());

            // Access the structure set of the plan
            if (plan.StructureSet != null)
            {
                Image image      = plan.StructureSet.Image;
                var   structures = plan.StructureSet.Structures;
                message += string.Format("\n* Image ID: {0}", image.Id);
                message += string.Format("\n* Size of the Structure Set associated with the plan: {0}.\n", structures.Count());

                // TODO show structure info each
                foreach (var structureSingle in plan.StructureSet.Structures)
                {
                    // check validation
                    if (!structureSingle.IsEmpty)
                    {
                        message += string.Format("{0} in volume {1:F2} cc" + Environment.NewLine, structureSingle.Name, structureSingle.Volume);
                    }
                }
            }
            // message += string.Format("\n* Number of Fractions: {0}.", plan.NumberOfFractions);

            // Handle brachytherapy plans separately from external beam plans
            if (plan is BrachyPlanSetup)
            {
                BrachyPlanSetup brachyPlan      = (BrachyPlanSetup)plan;
                var             catheters       = brachyPlan.Catheters;
                var             seedCollections = brachyPlan.SeedCollections;
                message += string.Format("\n* Number of Catheters: {0}.", catheters.Count());
                message += string.Format("\n* Number of Seed Collections: {0}.", seedCollections.Count());
            }
            else
            {
                var beams = plan.Beams;
                message += string.Format("\n* Number of Beams: {0}." + Environment.NewLine, beams.Count());

                // TODO show info of beams
                foreach (Beam beamSingle in plan.Beams.OrderBy(x => x.BeamNumber))
                {
                    message += string.Format("Beam name equal to {0} , ", beamSingle.Id);
                    message += string.Format("and MeterSet = {0}" + Environment.NewLine, beamSingle.Meterset.Value.ToString() + " " + beamSingle.Meterset.Unit.ToString());
                }
            }
            if (plan is IonPlanSetup)
            {
                IonPlanSetup ionPlan = plan as IonPlanSetup;
                IonBeam      beam    = ionPlan.IonBeams.FirstOrDefault();
                if (beam != null)
                {
                    message += string.Format("\n* Number of Lateral Spreaders in first beam: {0}.", beam.LateralSpreadingDevices.Count());
                    message += string.Format("\n* Number of Range Modulators in first beam: {0}.", beam.RangeModulators.Count());
                    message += string.Format("\n* Number of Range Shifters in first beam: {0}.", beam.RangeShifters.Count());
                }
            }

            // MessageBox.Show(message);
            window.Content = message;
        }
Пример #40
0
 public override VideoFrame GetFrame(int n, ScriptEnvironment env)
 {
     int nn = GetCacheSkipCount(n);
     return Child.GetFrame(nn, env);
 }
Пример #41
0
 public override void Execute(ScriptEnvironment env)
 {
     env.TryLabel = null;
 }
Пример #42
0
        protected virtual int[] GetSkipFrames(AVSValue args, ScriptEnvironment env)
        {
            int n = args[1].ArraySize();
            HashSet<int> f = new HashSet<int>();
            int max = vi.num_frames;
            for (int i = 0; i < n; ++i)
            {
                int skipFrm = args[1][i].AsInt();
                if (vi.num_frames > skipFrm)
                {
                    f.Add(skipFrm);
                }
            }

            return f.Distinct().OrderBy(key => key).ToArray<int>();
        }
Пример #43
0
        public override void Execute(ScriptEnvironment env)
        {
            var robot = env.GetSpecialArgument <Robot>();

            robot.Data[Argument] = env.Pop();
        }
Пример #44
0
 public ApplyDelFrm(AVSValue args, ScriptEnvironment env)
     : base(args, env)
 {
 }
Пример #45
0
 public ScriptCompiler(ScriptLogger logger, RuntimeDependencyResolver runtimeDependencyResolver)
 {
     Logger = logger;
     RuntimeDependencyResolver = runtimeDependencyResolver;
     _scriptEnvironment        = ScriptEnvironment.Default;
 }
Пример #46
0
 internal ScriptExecution(ScriptEnvironment env)
 {
     Environment = env;
 }
Пример #47
0
        public override VideoFrame GetFrame(int n, ScriptEnvironment env)
        {
            var frame = NewVideoFrame(env);

            if (realPlanar)
            {
                OverlayUtils.ResetChroma(frame);
            }
            OverlayUtils.MemSet(frame.GetWritePtr(), byte.MaxValue, frame.GetHeight() * frame.GetPitch());
            var stride    = frame.GetPitch();
            var pixelSize = frame.GetRowSize() / GetVideoInfo().width;
            var random    = new Random(seed == int.MaxValue ? n : seed);

            unsafe
            {
                void LeftRight(int length, Func <int, int> offset)
                {
                    if (length > 0)
                    {
                        for (var x = 0; x < length; x++)
                        {
                            var data        = (byte *)frame.GetWritePtr() + offset(x) * pixelSize;
                            var gradientVal = GradientVal(x, length);

                            for (var y = 0; y < height; y++, data += stride)
                            {
                                var val = gradientVal;
                                if (noise && random.Next(length + 1) > x && random.Next(length + 1) > x)
                                {
                                    val = 0;
                                }
                                if (val != byte.MaxValue)
                                {
                                    for (var i = 0; i < pixelSize; i++)
                                    {
                                        data[i] = val;
                                    }
                                }
                            }
                        }
                    }
                }

                void TopBottom(int length, Func <int, int> offset)
                {
                    if (length > 0)
                    {
                        for (var y = 0; y < length; y++)
                        {
                            var data        = (byte *)frame.GetWritePtr() + offset(rgb ? (height - y - 1) : y) * stride;
                            var gradientVal = GradientVal(y, length);

                            for (var x = 0; x < width; x++, data += pixelSize)
                            {
                                var val = gradientVal;
                                if (noise && random.Next(length + 1) > y && random.Next(length + 1) > y)
                                {
                                    val = 0;
                                }
                                if (val != byte.MaxValue && data[0] > val)
                                {
                                    for (var i = 0; i < pixelSize; i++)
                                    {
                                        data[i] = val;
                                    }
                                }
                            }
                        }
                    }
                }

                LeftRight(left, x => x);
                LeftRight(right, x => width - x - 1);
                TopBottom(top, y => y);
                TopBottom(bottom, y => height - y - 1);
            }
            return(frame);
        }
Пример #48
0
 public override void Execute(ScriptEnvironment env)
 {
 }
Пример #49
0
 private ScriptProjectProvider(ScriptParser scriptParser, ScriptFilesResolver scriptFilesResolver, LogFactory logFactory, ScriptEnvironment scriptEnvironment)
 {
     _logger              = logFactory.CreateLogger <ScriptProjectProvider>();
     _scriptParser        = scriptParser;
     _scriptFilesResolver = scriptFilesResolver;
     _scriptEnvironment   = scriptEnvironment;
 }
Пример #50
0
 public override void Execute(ScriptEnvironment env)
 {
     var robot = env.GetSpecialArgument<Robot>();
     env.Push(robot.Data.ContainsKey(Argument));
 }
Пример #51
0
 public Scaffolder(LogFactory logFactory)
 {
     _commandRunner     = new CommandRunner(logFactory);
     _scriptEnvironment = ScriptEnvironment.Default;
 }
 protected abstract void Execute(ScriptEnvironment env, Robot robot);
 public OwinScriptHost(IScriptPackManager scriptPackManager, ScriptEnvironment environment)
     : base(scriptPackManager, environment)
 {
 }
Пример #54
0
 protected override void Initialize()
 {
     base.Initialize();
     Options.LanguageProvider = ScriptEnvironment.GetEnvironment().GetLanguageProvider(typeof(IronSchemeLanguageProvider));
 }
Пример #55
0
 public NetFxAnalyzer(ScriptEnvironment script_env, string name, object modules, IConfiguration configuration, Dictionary <string, object> application_options) :
     base(script_env, name, modules, configuration, application_options)
 {
     this.Module = (ModuleDefinition)this._Modules;
 }
Пример #56
0
 public ScaffoldingTests(ITestOutputHelper testOutputHelper)
 {
     _scriptEnvironment = ScriptEnvironment.Default;
     testOutputHelper.Capture();
 }
Пример #57
0
        public override void Execute(ScriptEnvironment env)
        {
            var pc = (int)env.CallPop();

            env.ProgramCounter = pc;
        }
Пример #58
0
        public static void Initialize()
        {
            if (initialized)
            {
                return;
            }

            initialized = true;

            instance = new Wrapper();

            serverasm = Assembly.GetAssembly(typeof(CitizenMP.Server.Resources.Resource));

            if (serverasm != null)
            {
                PlayerScriptFunctions = serverasm.GetType("CitizenMP.Server.Resources.PlayerScriptFunctions");

                if (PlayerScriptFunctions != null)
                {
                    PSFDropPlayer    = PlayerScriptFunctions.GetMethod("DropPlayer", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
                    PSFTempBanPlayer = PlayerScriptFunctions.GetMethod("TempBanPlayer", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
                    PSFGetHostId     = PlayerScriptFunctions.GetMethod("GetHostId", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
                }

                EventScriptFunctions = serverasm.GetType("CitizenMP.Server.Resources.EventScriptFunctions");

                if (EventScriptFunctions != null)
                {
                    ESFTriggerClientEvent  = EventScriptFunctions.GetMethod("TriggerClientEvent_f", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
                    ESFRegisterServerEvent = EventScriptFunctions.GetMethod("RegisterServerEvent_f", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
                    ESFTriggerEvent        = EventScriptFunctions.GetMethod("TriggerEvent_f", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
                    ESFCancelEvent         = EventScriptFunctions.GetMethod("CancelEvent_f", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
                    ESFWasEventCanceled    = EventScriptFunctions.GetMethod("WasEventCanceled_f", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
                }

                ScriptEnvironment = serverasm.GetType("CitizenMP.Server.Resources.ScriptEnvironment");

                if (ScriptEnvironment != null)
                {
                    SESetTimeout      = ScriptEnvironment.GetMethod("SetTimeout_f", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
                    SEAddEventHandler = ScriptEnvironment.GetMethod("AddEventHandler_f", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
                    SEGetInstanceId   = ScriptEnvironment.GetMethod("GetInstanceId", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);

                    SECurrentEnvironment = ScriptEnvironment.GetProperty("CurrentEnvironment", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public).GetValue(null);
                    EventHandlers        = (Dictionary <string, List <Delegate> >)ScriptEnvironment.GetField("m_eventHandlers", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public).GetValue(SECurrentEnvironment);

                    SELuaEnvironment = ScriptEnvironment.GetField("m_luaEnvironment", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public).GetValue(SECurrentEnvironment);

                    SEScriptTimer = ScriptEnvironment.GetNestedType("ScriptTimer", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);

                    if (SEScriptTimer != null)
                    {
                        SEScriptTimerList = (IList)ScriptEnvironment.GetField("m_timers", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public).GetValue(SECurrentEnvironment);

                        SEScriptTimerFunction = SEScriptTimer.GetProperty("Function", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
                        SEScriptTimerTickFrom = SEScriptTimer.GetProperty("TickFrom", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
                    }
                }

                ClientInstances = serverasm.GetType("CitizenMP.Server.ClientInstances");

                if (ClientInstances != null)
                {
                    Clients        = (ReadOnlyDictionary <string, Client>)ClientInstances.GetProperty("Clients", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public).GetValue(null);
                    ClientsByNetId = (ReadOnlyDictionary <ushort, Client>)ClientInstances.GetProperty("ClientsByNetId", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public).GetValue(null);
                }

                ResourceScriptFunctions = serverasm.GetType("CitizenMP.Server.Resources.ResourceScriptFunctions");

                if (ResourceScriptFunctions != null)
                {
                    RSFStopResource  = ScriptEnvironment.GetMethod("StopResource_f", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
                    RSFStartResource = ScriptEnvironment.GetMethod("StartResource_f", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
                    RSFSetGameType   = ScriptEnvironment.GetMethod("SetGameType_f", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
                    RSFSetMapName    = ScriptEnvironment.GetMethod("SetMapName_f", BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public);
                }

                /*foreach (Type t in serverasm.GetTypes())
                 * {
                 *  foreach (MethodInfo mi in t.GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public))
                 *  {
                 *      foreach (object attr in mi.GetCustomAttributes()) if (attr.GetType().ToString().Contains("LuaMember")) instance.Print(t + " (" + mi.ReturnType + ") " + mi.Name, string.Join(", ", mi.GetParameters().Select(pi => "(" + pi.ParameterType + ") " + pi.Name)));
                 *
                 *      //instance.Print(t + " (" + mi.ReturnType + ") " + mi.Name, string.Join(", ", mi.GetParameters().Select(pi => "(" + pi.ParameterType + ") " + pi.Name)));
                 *  }
                 *
                 *  //foreach (FieldInfo fi in t.GetFields(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public)) instance.Print(t + " (" + fi.FieldType + ") " + fi.Name);
                 *
                 *  //foreach (PropertyInfo pi in t.GetProperties(BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.Public)) instance.Print(t + " (" + pi.PropertyType + ") " + pi.Name);
                 * }*/
            }

            ScriptsFolder = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), "resources", "ServerWrapper", "Scripts");

            if (!Directory.Exists(ScriptsFolder))
            {
                Directory.CreateDirectory(ScriptsFolder);
            }

            /*AppDomain.CurrentDomain.AssemblyResolve += (sender, e) =>
             * {
             *  if (!assemblies.ContainsKey(e.Name))
             *  {
             *      try
             *      {
             *          foreach (string file in Directory.GetFiles(path, "*.dll"))
             *          {
             *              if (e.Name == AssemblyName.GetAssemblyName(file).FullName)
             *              {
             *                  assemblies.Add(AssemblyName.GetAssemblyName(file).FullName, Assembly.Load(File.ReadAllBytes(file)));
             *
             *                  break;
             *              }
             *          }
             *      }
             *      catch (Exception ex)
             *      {
             *          instance.PrintException(ex);
             *      }
             *  }
             *
             *  return assemblies.ContainsKey(e.Name) ? assemblies[e.Name] : null;
             * };*/

            Load(ScriptsFolder);

            instance.AddEventHandler("rconCommand", new Action <string, object>((command, args) =>
            {
                string c = command.ToLower();

                if (c == "reloadscripts")
                {
                    instance.CancelEvent();

                    if (_scripts.Count > 0)
                    {
                        Reload(ScriptsFolder);
                    }
                }
                else if (c == "loadscripts")
                {
                    instance.CancelEvent();

                    if (_scripts.Count == 0)
                    {
                        Load(ScriptsFolder);
                    }
                }
                else if (c == "unloadscripts")
                {
                    instance.CancelEvent();

                    if (_scripts.Count > 0)
                    {
                        Unload(ScriptsFolder);
                    }
                }
                else if (c == "swupdate")
                {
                    instance.CancelEvent();

                    Process.Start("explorer.exe", "https://forum.fivem.net/t/release-c-net-wrapper-for-server-side-scripts/20325");
                }
                else
                {
                    lock (scripteventhandlers) foreach (IServerScript script in scripteventhandlers.Keys)
                        {
                            if (scripteventhandlers[script].ContainsKey("rconCommand"))
                            {
                                foreach (Delegate handler in scripteventhandlers[script]["rconCommand"])
                                {
                                    handler.DynamicInvoke(command, args);
                                }
                            }
                        }
                }

                /*new Action<string, List<object>>((c, a) =>
                 * {
                 *  if (c == "reloadscripts")
                 *  {
                 *      instance.CancelEvent();
                 *
                 *      if (_scripts.Count > 0) Reload(ScriptsFolder);
                 *  }
                 *  else if (c == "loadscripts")
                 *  {
                 *      instance.CancelEvent();
                 *
                 *      if (_scripts.Count == 0) Load(ScriptsFolder);
                 *  }
                 *  else if (c == "unloadscripts")
                 *  {
                 *      instance.CancelEvent();
                 *
                 *      if (_scripts.Count > 0) Unload(ScriptsFolder);
                 *  }
                 *  else if (c == "swupdate")
                 *  {
                 *      instance.CancelEvent();
                 *
                 *      Process.Start("explorer.exe", "https://forum.fivem.net/t/release-c-net-wrapper-for-server-side-scripts/20325");
                 *  }
                 * })(command, (List<object>)ConvertArgsFromNLua(args)[0]);*/
            }));


            new Thread(() =>
            {
                int CurrentMajor, CurrentMinor, CurrentBuild, CurrentRevision, NewMajor, NewMinor, NewBuild;
                string[] currentver = Assembly.GetExecutingAssembly().GetName().Version.ToString().Split('.');
                if (currentver.Length < 1 || !int.TryParse(currentver[0], out CurrentMajor))
                {
                    CurrentMajor = 1;
                }
                if (currentver.Length < 2 || !int.TryParse(currentver[1], out CurrentMinor))
                {
                    CurrentMinor = 2;
                }
                if (currentver.Length < 3 || !int.TryParse(currentver[2], out CurrentBuild))
                {
                    CurrentBuild = 0;
                }
                if (currentver.Length < 4 || !int.TryParse(currentver[3], out CurrentRevision))
                {
                    CurrentRevision = 0;
                }
                string current = CurrentMajor + "." + CurrentMinor + "." + CurrentBuild, latest = "";

                //CurrentMajor = 0;

                bool update = false;

                while (true)
                {
                    try
                    {
                        if (!update)
                        {
                            using (WebClient w = new WebClient())
                            {
                                w.Proxy = null;
                                w.Headers.Add("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.2; .NET CLR 1.0.3705;)"); // Fails without a user-agent header.

                                JObject json = JObject.Parse(w.DownloadString("https://api.github.com/repos/DorCoMaNdO/FiveMServerWrapper/releases/latest"));
                                string[] ver = json["tag_name"].ToString().Split('.');
                                if (ver.Length < 1 || !int.TryParse(ver[0], out NewMajor))
                                {
                                    NewMajor = 1;
                                }
                                if (ver.Length < 2 || !int.TryParse(ver[1], out NewMinor))
                                {
                                    NewMinor = 2;
                                }
                                if (ver.Length < 3 || !int.TryParse(ver[2], out NewBuild))
                                {
                                    NewBuild = 0;
                                }
                                latest = NewMajor + "." + NewMinor + "." + NewBuild;

                                update = NewMajor > CurrentMajor || NewMajor == CurrentMajor && NewMinor > CurrentMinor || NewMajor == CurrentMajor && NewMinor == CurrentMinor && NewBuild > CurrentBuild;
                            }
                        }

                        if (update)
                        {
                            instance.Print("---------------------------------------------------------------------------------------------------");
                            instance.Print("A ServerWrapper update is available!");
                            instance.Print("Current version: " + current + ", latest version: " + latest + ".");
                            instance.Print("For more info, visit https://forum.fivem.net/t/release-c-net-wrapper-for-server-side-scripts/20325.");
                            instance.Print("Enter the command \"swupdate\" to open the link above in your default browser.");
                            instance.Print("---------------------------------------------------------------------------------------------------");
                        }
                    }
                    catch (Exception e)
                    {
                        instance.Print(PrintType.Error, "Update check failed, will try again in 10 minutes.");
                        instance.PrintException(e);
                    }

                    Thread.Sleep(600000);
                }
            }).Start();
        }
Пример #59
0
        public void Execute(ScriptContext context, System.Windows.Window window, ScriptEnvironment environment)
        {
            // Retrieve the count of plans displayed in Scope Window
            int scopePlanCount = context.PlansInScope.Count();

            if (scopePlanCount == 0)
            {
                MessageBox.Show("Scope Window does not contain any plans.");
                return;
            }

            // Retrieve names for different types of plans
            List <string> externalPlanIds = new List <string>();
            List <string> brachyPlanIds   = new List <string>();
            List <string> protonPlanIds   = new List <string>();

            foreach (var ps in context.PlansInScope)
            {
                // KK: "is" compares the type. Equiv to ps.GetType() == typeof(BrachyPlanSetup))
                if (ps is BrachyPlanSetup)
                {
                    brachyPlanIds.Add(ps.Id);
                }
                else if (ps is IonPlanSetup)
                {
                    protonPlanIds.Add(ps.Id);
                }
                else
                {
                    externalPlanIds.Add(ps.Id);
                }
            }

            // Construct output message
            string message = string.Format("Hello {0}, the number of plans in Scope Window is {1}.",
                                           context.CurrentUser.Name,
                                           scopePlanCount);

            if (externalPlanIds.Count > 0)
            {
                message += string.Format("\nPlan(s) {0} are external beam plans.", string.Join(", ", externalPlanIds));
            }
            if (brachyPlanIds.Count > 0)
            {
                message += string.Format("\nPlan(s) {0} are brachytherapy plans.", string.Join(", ", brachyPlanIds));
            }
            if (protonPlanIds.Count > 0)
            {
                message += string.Format("\nPlan(s) {0} are proton plans.", string.Join(", ", protonPlanIds));
            }

            // Display additional information. Use the active plan if available.
            PlanSetup plan = context.PlanSetup != null ? context.PlanSetup : context.PlansInScope.ElementAt(0);

            message += string.Format("\n\nAdditional details for plan {0}:", plan.Id);

            // Access the structure set of the plan
            if (plan.StructureSet != null)
            {
                Common.Model.API.Image image = plan.StructureSet.Image;
                var structures = plan.StructureSet.Structures;
                message += string.Format("\n* Image ID: {0}", image.Id);
                message += string.Format("\n* Size of the Structure Set associated with the plan: {0}.", structures.Count());

                string structureNames = "";
                foreach (var s in structures)
                {
                    structureNames += String.Format("\n\t{0}: volume is {1:F2} cc.", s.Id, s.Volume);
                }
                message += structureNames;
            }


            message += string.Format("\n* Number of Fractions: {0}.", plan.NumberOfFractions);

            message += string.Format("\n \t Dose per Fraction: {0}.", plan.DosePerFraction);

            // Handle brachytherapy plans separately from external beam plans
            if (plan is BrachyPlanSetup)
            {
                BrachyPlanSetup brachyPlan      = (BrachyPlanSetup)plan;
                var             catheters       = brachyPlan.Catheters;
                var             seedCollections = brachyPlan.SeedCollections;
                message += string.Format("\n* Number of Catheters: {0}.", catheters.Count());
                message += string.Format("\n* Number of Seed Collections: {0}.", seedCollections.Count());
            }
            else
            {
                var beams = plan.Beams;
                message += string.Format("\n* Number of Beams: {0}.", beams.Count());

                string beamNames = "";
                foreach (var b in beams.OrderBy(x => x.BeamNumber))
                {
                    beamNames += String.Format("\n\t{0} has {1} MU.", b.Id, b.Meterset.Value);
                }
                message += beamNames;
            }
            if (plan is IonPlanSetup)
            {
                IonPlanSetup ionPlan = plan as IonPlanSetup;
                IonBeam      beam    = ionPlan.IonBeams.FirstOrDefault();
                if (beam != null)
                {
                    message += string.Format("\n* Number of Lateral Spreaders in first beam: {0}.", beam.LateralSpreadingDevices.Count());
                    message += string.Format("\n* Number of Range Modulators in first beam: {0}.", beam.RangeModulators.Count());
                    message += string.Format("\n* Number of Range Shifters in first beam: {0}.", beam.RangeShifters.Count());
                }
            }

            //MessageBox.Show(message);
            window.Background = Brushes.Blue;
            window.Content    = new TextBlock
            {
                Foreground = Brushes.White,
                FontFamily = new FontFamily("Ariel"),
                FontSize   = 18,
                Text       = message
            };
            //window.Content = message;
        }
Пример #60
0
        private void HandleException(ScriptException e, ScriptEnvironment env)
        {
            if (env.TryLabel == null)
            {
                e.Environment = env;
                throw e;
            }

            env.Push(e.InnerException);
            env.JumpToLabel(env.TryLabel);
            env.TryLabel = null;
        }