Example #1
0
        public void TickWithIterations(Rider state)
        {
            var collisions = new ConcurrentDictionary <int, StandardLine>();

            state.TickMomentum();
            if (state.iterations == null)
            {
                state.iterations = new List <Rider>();
            }
            state.iterations.Clear();
            for (var iteration = 0; iteration < 6; iteration++)
            {
                state.SatisfyScarf();
                state.iterations.Add(state.Clone());
                state.SatisfyDistance();
                state.SatisfyBoundaries(this, collisions);
            }
            var points   = state.ModelAnchors;
            var sleddiff = points[3].Position - points[0].Position;

            if (sleddiff.X * (points[1].Position.Y - points[0].Position.Y) -
                sleddiff.Y * (points[1].Position.X - points[0].Position.X) < 0)
            {
                state.Crashed    = true;
                state.SledBroken = true;
            }
            if (sleddiff.X * (points[5].Position.Y - points[4].Position.Y) -
                sleddiff.Y * (points[5].Position.X - points[4].Position.X) > 0)
            {
                state.Crashed    = true;
                state.SledBroken = true;
            }
            state.SatisfyScarf();
        }
Example #2
0
        public HashSet <int> Diagnose(Rider state)
        {
            var ret = new HashSet <int>();

            if (state.Crashed)
            {
                return(ret);
            }
            var s = state.Clone();

            s.TickMomentum();

            for (var iteration = 0; iteration < 6; iteration++)
            {
                for (var i = 0; i < s.ModelLines.Length; i++)
                {
                    s.ModelLines[i].satisfyDistance(s);
                    if (s.Crashed)
                    {
                        ret.Add(i);
                        s.Crashed = false;
                    }
                }
                s.SatisfyBoundaries(this, null);
            }
            var sleddiff = s.ModelAnchors[3].Position - s.ModelAnchors[0].Position;

            if (sleddiff.X * (s.ModelAnchors[1].Position.Y - s.ModelAnchors[0].Position.Y) -
                sleddiff.Y * (s.ModelAnchors[1].Position.X - s.ModelAnchors[0].Position.X) < 0)
            {
                s.Crashed    = true;
                s.SledBroken = true;
                ret.Add(-1);
            }
            if (sleddiff.X * (s.ModelAnchors[5].Position.Y - s.ModelAnchors[4].Position.Y) -
                sleddiff.Y * (s.ModelAnchors[5].Position.X - s.ModelAnchors[4].Position.X) > 0)
            {
                s.Crashed    = true;
                s.SledBroken = true;
                ret.Add(-2);
            }
            return(ret);
        }
Example #3
0
        public void Render()
        {
            var rect        = Camera.GetRenderRect(Zoom, game.RenderSize.Width, game.RenderSize.Height);
            var st          = OpenTK.Input.Keyboard.GetState();
            var needsredraw = (!_trackrect.Contains(rect.Left, rect.Top) ||
                               !_trackrect.Contains(rect.Left + rect.Width, rect.Top + rect.Height));

            if (!needsredraw)
            {
                var viewport = rect.Inflate(rect.Width, rect.Height);
                if (viewport.Width < _trackrect.Width / 3 && viewport.Height < _trackrect.Height / 3)
                {
                    needsredraw = true;
                }
            }
            var drawcolor = !Animating || Paused || game.SettingColorPlayback;

            if (game.SettingPreviewMode)
            {
                drawcolor = false;
            }
            var knob       = 0;
            var adjustTool = game.SelectedTool as LineAdjustTool;

            if (adjustTool != null && (!Animating || Paused))
            {
                knob = 1;
                if ((!adjustTool.Started && (st[OpenTK.Input.Key.AltLeft] || st[OpenTK.Input.Key.AltRight])) ||
                    adjustTool.LifeLock)
                {
                    knob = 2;
                }
            }
            if (needsredraw || RequiresUpdate)
            {
                EnterTrackRead();
                var viewport = rect.Inflate(rect.Width, rect.Height);
                var lines    = _track.GetLinesInRect(viewport, false, true);
                _trackrect = viewport;
                _renderer.UpdateViewport(lines);
                ExitTrackRead();
            }
            _renderer.Render(_track, drawcolor, knob, game.SettingRenderGravityWells);
            _sceneryrenderer.Render(drawcolor);
            List <RiderDrawCommand> commands = new List <RiderDrawCommand>();

            EnterPlayback();
            if (game.IterationsOffset != 6 && Frame != 0 && Animating && Paused)
            {
                var renderstate = _track.RiderStates[Frame - 1].Clone();
                _track.TickWithIterations(renderstate);
                commands.Add(new RiderDrawCommand(game.IterationsOffset, renderstate, game.SettingDrawContactPoints ? 0.4f : 1, true,
                                                  game.SettingDrawContactPoints, game.SettingMomentumVectors));
            }
            else
            {
                commands.Add(new RiderDrawCommand(RiderState.Clone(), game.SettingDrawContactPoints ? 0.4f : 1, true,
                                                  game.SettingDrawContactPoints, game.SettingMomentumVectors));
            }
            if (game.SettingOnionSkinning && _track.RiderStates.Count != 0 && Animating)
            {
                const int onions      = 10;
                Rider[]   onionstates = new Rider[onions * 2];
                for (int i = 0; i < onions; i++)
                {
                    var frame = _track.Frame - (onions - i);
                    if (frame > 0)
                    {
                        onionstates[i] = _track.RiderStates[frame].Clone();
                    }
                }
                Rider positivestate = _track.RiderStates[_track.Frame].Clone();

                for (int i = onions + 1; i < onions * 2; i++)
                {
                    _track.Tick(positivestate);
                    onionstates[i] = positivestate.Clone();
                }

                foreach (var state in onionstates)
                {
                    if (state == null)
                    {
                        continue;
                    }
                    commands.Add(new RiderDrawCommand(state, 0.2f, false,
                                                      game.SettingDrawContactPoints, game.SettingMomentumVectors));
                }
            }
            if (_flag != null)
            {
                commands.Add(new RiderDrawCommand(_flag.State.Clone(), 0.6f, false,
                                                  game.SettingDrawContactPoints, game.SettingMomentumVectors));
            }
            ExitPlayback();
            foreach (var v in commands)            //todo rider vbo for every rider, massive improvements.
            {
                if (v.iteration != -1)
                {
                    GameRenderer.DrawIteration(v.opacity, v.state, v.iteration, v.momentum, v.contactpoints);
                }
                else
                {
                    GameRenderer.DrawRider(v.opacity, v.state, v.scarf, v.contactpoints, v.momentum);
                }
            }
        }