コード例 #1
0
        public void SceneFormatterTest()
        {
            var input = new[] { "③□□□", "⑤□□②", "□⑤⑥④", "①□□⑥" };
            var scene = MemoScene.Parse(input);

            Assert.Equal(scene.ToString(), string.Join(Environment.NewLine, input));
        }
コード例 #2
0
        public static MemoScene ParseScene(IReadOnlyList <string> lines)
        {
            var scene = new MemoScene();

            Debug.Assert(lines.Count == 4);
            Debug.Assert(lines.All(l => l.Length >= 4));

            for (var row = 0; row < 4; row++)
            {
                for (var col = 0; col < 4; col++)
                {
                    var c = lines[row][col];

                    Debug.Assert(AllValidCharset.Contains(c));

                    foreach (var charset in AllNumberCharsets)
                    {
                        var index = charset.IndexOf(c);
                        if (index >= 0)
                        {
                            scene[row, col] = new MemoNote
                            {
                                Type    = MemoNote.NoteType.Click,
                                Ordinal = index + 1
                            };
                            break;
                        }
                    }
                }
            }

            for (var row = 0; row < 4; row++)
            {
                for (var col = 0; col < 4; col++)
                {
                    var direction = GetDirection(lines[row][col]);
                    if (direction != MemoNote.Direction.Undefined)
                    {
                        SetHoldNote(scene, row, col, direction);
                    }
                }
            }

            return(scene);
        }
コード例 #3
0
        public static string[] SceneToStrings(MemoScene scene)
        {
            var scene2D = scene as IEnumerable <IEnumerable <MemoNote> >;
            var output  = scene2D.Select(line => line.Select(MemoNoteFormatter.NoteToChar).ToArray()).ToArray();

            for (var row = 0; row < 4; row++)
            {
                for (var col = 0; col < 4; col++)
                {
                    var note = scene[row, col];
                    if (note.Type == MemoNote.NoteType.Hold)
                    {
                        FillHoldPath(ref output, row, col, note.HoldDirection, note.HoldSpan);
                    }
                }
            }

            return(output.Select(line => new string(line)).ToArray());
        }
コード例 #4
0
        public static MemoMeasure ParseMeasure(IReadOnlyList <Match> matches)
        {
            Debug.Assert((matches.Count > 0) && (matches.Count % 4 == 0));
            Debug.Assert(matches.All(m => m.Groups["buttons"].Success));

            var measure = new MemoMeasure();

            var scenes = Enumerable.Range(0, matches.Count / 4)
                         .Select(i => matches.Skip(i * 4).Take(4).ToArray())
                         .Select(s => MemoScene.Parse(s.Select(m => m.Groups["buttons"].Value).ToArray()));

            var beats = matches.Where(m => m.Groups["beat"].Success)
                        .Select(m => MemoBeat.Parse(m.Groups["beat"].Value));

            measure.Scenes.AddRange(scenes);
            measure.Beats.AddRange(beats);

            return(measure);
        }
コード例 #5
0
        private static void SetHoldNote(MemoScene scene, int row, int col, MemoNote.Direction direction)
        {
            var rowOffset = RowOffset[direction];
            var colOffset = ColOffset[direction];

            for (var span = 1;; span++)
            {
                row += rowOffset;
                col += colOffset;

                if (scene[row, col].Type == MemoNote.NoteType.Click)
                {
                    scene[row, col] = new MemoNote
                    {
                        Type          = MemoNote.NoteType.Hold,
                        Ordinal       = scene[row, col].Ordinal,
                        HoldSpan      = span,
                        HoldDirection = direction
                    };
                    break;
                }
            }
        }