Esempio n. 1
0
 private void NoteHit(DrawingNote note, int songTime)
 {
     _hitEffectStartTime[note.HitPosition] = songTime;
     if (note.DrawType == NoteDrawType.FlickLeft || note.DrawType == NoteDrawType.FlickRight)
     {
         ShallPlaySoundEffect[1] = true;
     }
     else
     {
         ShallPlaySoundEffect[0] = true;
     }
 }
        public void BeginPreview(Score score, double targetFps, int startTime, double approachTime)
        {
            // wait if not loaded yet
            if (!_loaded)
            {
                new Task(() => {
                    _loadHandle.WaitOne();
                    Dispatcher.BeginInvoke(
                        new Action <Score, double, int, double>(BeginPreview),
                        score, targetFps, startTime, approachTime);
                }).Start();
                return;
            }

            // setup parameters

            _score     = score;
            _targetFps = targetFps;
            _startTime = startTime;

            // prepare notes

            foreach (var note in _score.Notes)
            {
                // can I draw it?
                if (note.Type != NoteType.TapOrFlick && note.Type != NoteType.Hold && note.Type != NoteType.Slide)
                {
                    continue;
                }

                var pos = (int)note.FinishPosition;
                if (pos == 0)
                {
                    pos = (int)note.StartPosition;
                }

                if (pos == 0)
                {
                    continue;
                }

                NoteDrawType drawType;
                if (note.IsHoldStart || (note.IsHoldEnd && note.IsTap))
                {
                    drawType = NoteDrawType.Hold;
                }
                else if (note.ShouldBeRenderedAsFlick)
                {
                    drawType = (NoteDrawType)note.FlickType;
                }
                else if (note.ShouldBeRenderedAsSlide)
                {
                    drawType = NoteDrawType.Slide;
                }
                else
                {
                    drawType = NoteDrawType.Tap;
                }

                var snote = new DrawingNote {
                    Note        = note,
                    Done        = false,
                    Duration    = 0,
                    IsHoldStart = note.IsHoldStart,
                    Timing      = (int)(note.HitTiming * 1000),
                    LastT       = 0,
                    HitPosition = pos - 1,
                    DrawType    = drawType
                };

                if (note.IsHoldStart)
                {
                    snote.Duration = (int)(note.HoldTarget.HitTiming * 1000) - (int)(note.HitTiming * 1000);
                }

                // skip notes that are done before start time
                if (snote.Timing + snote.Duration < startTime)
                {
                    continue;
                }

                // skip hit effect of hold note start if started before
                if (snote.IsHoldStart && snote.Timing < startTime)
                {
                    snote.EffectShown = true;
                }

                _notes.Add(snote);
            }

            // end if no notes
            if (_notes.Count == 0)
            {
                // TODO: alert user?
                IsPreviewing = false;
                return;
            }

            _notes.Sort((a, b) => a.Timing - b.Timing);

            // prepare note relationships

            foreach (var snote in _notes)
            {
                if (snote.IsHoldStart)
                {
                    snote.HoldTarget = _notes.FirstOrDefault(note => note.Note.ID == snote.Note.HoldTargetID);
                }

                if (snote.Note.HasNextSync)
                {
                    snote.SyncTarget = _notes.FirstOrDefault(note => note.Note.ID == snote.Note.NextSyncTarget.ID);
                }

                if (snote.Note.HasNextFlickOrSlide)
                {
                    snote.GroupTarget = _notes.FirstOrDefault(note => note.Note.ID == snote.Note.NextFlickOrSlideNoteID);
                }
            }

            // music

            _shouldPlayMusic = _window != null && _window.MusicLoaded;

            // prepare bars

            if (_window != null && _window.PreviewBarLevel > 0)
            {
                var level = _window.PreviewBarLevel;

                foreach (var bar in score.Bars)
                {
                    _bars.Add(new DrawingBar {
                        DrawType = 0, Timing = (int)(bar.StartTime * 1000)
                    });
                    if (level > 1)
                    {
                        for (int sig = 0; sig < bar.Signature; ++sig)
                        {
                            if (sig > 0)
                            {
                                _bars.Add(new DrawingBar {
                                    DrawType = 1, Timing = (int)(bar.TimeAtSignature(sig) * 1000)
                                });
                            }

                            if (level > 2 && bar.GridPerSignature % 4 == 0)
                            {
                                for (int grid = bar.GridPerSignature / 4; grid < bar.GridPerSignature; grid += bar.GridPerSignature / 4)
                                {
                                    _bars.Add(new DrawingBar {
                                        DrawType = 2,
                                        Timing   = (int)(bar.TimeAtGrid(sig * bar.GridPerSignature + grid) * 1000)
                                    });
                                }
                            }
                        }
                    }
                }
            }

            // prepare canvas

            approachTime *= ActualHeight / 484.04;
            MainCanvas.Initialize(_notes, _bars, approachTime);

            // hit sound

            LoadHitSounds();
            new Task(HitSoundTask).Start();

            // go

            if (_shouldPlayMusic)
            {
                StartMusic(_startTime);
            }

            _task = new Task(DrawPreviewFrames);
            _task.Start();
        }
Esempio n. 3
0
 private void SetNotePosition(DrawingNote note, double t)
 {
     note.Y = _noteStartY + t * (_noteEndY - _noteStartY);
 }