Beispiel #1
0
        public async Task Cleanup()
        {
            const string source = "portal2_pausing.dem";

            var parser = new SourceParser();
            var demo   = await parser.ParseFromFileAsync(Paths.Demos + source);

            bool RemovePacket = false;
            var  copy         = demo.Messages.ToArray();

            demo.Messages.CopyTo(copy);

            var index = 0;

            foreach (var msg in copy)
            {
                if (msg.Tick > 0)
                {
                    if (msg is ConsoleCmd console)
                    {
                        if (console.Command == "gameui_activate")
                        {
                            RemovePacket = true;
                        }
                        else if (console.Command == "gameui_hide")
                        {
                            RemovePacket = false;
                        }
                    }
                    else if ((msg is UserCmd) || (msg is Packet))
                    {
                        if (RemovePacket)
                        {
                            demo.Messages.RemoveAt(index);
                            --index;
                        }
                    }
                }
                ++index;
            }

            var exporter = new SourceExporter();
            await exporter.ExportToFileAsync(Paths.Demos + "portal2_cleanup.dem", demo);
        }
Beispiel #2
0
        public async Task Modification()
        {
            const string source      = "portal2_sp.dem";
            const string destination = "portal2_sp_edit.dem";

            var parser   = new SourceParser();
            var exporter = new SourceExporter();

            var demo = await parser.ParseFromFileAsync(Paths.Demos + source);

            var demo2 = default(SourceDemo);

            await exporter.ExportToFileAsync(Paths.Export + destination, demo);

            try
            {
                Console.WriteLine("Parsing exported demo...");
                demo2 = await parser.ParseFromFileAsync(Paths.Export + destination);
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
            }
        }
Beispiel #3
0
        public async Task Splice()
        {
            const string source1 = "ademo.dem";
            const string source2 = "ademo2.dem";
            const string source3 = "ademo2.dem";
            const string output  = "splice.dem";

            var demos = new List <SourceDemo>();
            var files = new List <string>()
            {
                Paths.Test + source1,
                Paths.Test + source2,
                Paths.Test + source3,
            };

            var parser   = new SourceParser();
            var exporter = new SourceExporter();

            if (files.Count < 2)
            {
                throw new InvalidOperationException("Need at least two demos for merging them together.");
            }

            foreach (var source in files)
            {
                var demo = await parser.ParseFromFileAsync(source);

                demo.Messages.RemoveAll(m => m.Name == "Stop");
                demos.Add(demo);
            }

            var result = demos.First();
            var tick   = 0;

            foreach (var demo in demos.Skip(1))
            {
                tick = result.PlaybackTicks;

                result.PlaybackTicks  += demo.PlaybackTicks;
                result.PlaybackTime   += demo.PlaybackTime;
                result.PlaybackFrames += demo.PlaybackFrames;

                var messages = demo.Messages.Where(m =>
                {
                    return((m is Packet) ||
                           (m is DataTables) ||
                           (m is UserCmd) ||
                           (m is ConsoleCmd) ||
                           (m is Stop));
                });

                foreach (DemoMessage msg in messages)
                {
                    msg.Tick += tick;
                }

                result.Messages.AddRange(messages);
            }
            result.Messages.Add(new Stop());

            await exporter.ExportToFileAsync(Paths.Export + output, result);
        }