### C# Beat Saber Map Format Conversion (V2 to V3)

Source: https://context7.com/beatleader/beatleader-parser/llms.txt

Demonstrates how the BeatLeader Parser library automatically converts Beat Saber map data from V2 to V3 format upon loading. The example shows how to load a map and access V3-specific data like BPM and NJS events, regardless of the original map version.

```csharp
using beatleader_parser;
using Parser.Map.Difficulty.V3.Base;
using Parser.Map.Difficulty.V2.Base;

// V2 to V3 conversion (happens automatically during load)
var parser = new Parse();
var map = parser.TryLoadZip(memoryStream);

// All difficulties are now in V3 format regardless of source
if (map != null && map.Count > 0)
{
    foreach (var diff in map[0].Difficulties)
    {
        // Always V3 format
        Console.WriteLine($"Version: {diff.Data.Version}");
        Console.WriteLine($"Notes: {diff.Data.Notes.Count}");
        Console.WriteLine($"Bombs: {diff.Data.Bombs.Count}");
        Console.WriteLine($"Arcs: {diff.Data.Arcs.Count}");
        Console.WriteLine($"Chains: {diff.Data.Chains.Count}");

        // V3 features available
        if (diff.Data.bpmEvents.Count > 0)
        {
            Console.WriteLine("Contains variable BPM");
        }
        if (diff.Data.njsEvents.Count > 0)
        {
            Console.WriteLine("Contains variable NJS");
        }
    }
}
```

--------------------------------

### Accessing Arcs (Sliders) in Beatleader Maps

Source: https://context7.com/beatleader/beatleader-parser/llms.txt

Demonstrates how to load a Beatleader map and iterate through its arcs (sliders). It shows how to access properties like start and end times, coordinates, direction, color, and anchor mode. Requires the beatleader-parser library.

```csharp
using beatleader_parser;

var parser = new Parse();
var map = parser.TryLoadPath("/path/to/map");

if (map != null)
{
    var diff = map.Difficulties[0];

    Console.WriteLine($"Arcs/Sliders: {diff.Data.Arcs.Count}");

    foreach (var arc in diff.Data.Arcs)
    {
        Console.WriteLine($"Arc from {arc.Seconds:F3}s to {arc.TailInSeconds:F3}s");
        Console.WriteLine($"  Head: ({arc.x}, {arc.y}) direction {arc.CutDirection}");
        Console.WriteLine($"  Tail: ({arc.tx}, {arc.ty}) direction {arc.TailCutDirection}");
        Console.WriteLine($"  Color: {arc.Color}");
        Console.WriteLine($"  Multiplier: {arc.Multiplier}, Tail Multiplier: {arc.TailMultiplier}");
        Console.WriteLine($"  Anchor Mode: {arc.AnchorMode}");
    }
}
```

--------------------------------

### Accessing Walls (Obstacles) in Beatleader Maps

Source: https://context7.com/beatleader/beatleader-parser/llms.txt

Provides C# code to access wall (obstacle) data from a Beatleader map. It details how to get the wall's timing, position, dimensions, duration, and Ninja Speed (NJS). Requires the beatleader-parser library.

```csharp
using beatleader_parser;

var parser = new Parse();
var map = parser.TryLoadPath("/path/to/map");

if (map != null)
{
    var diff = map.Difficulties[0];

    Console.WriteLine($"Walls: {diff.Data.Walls.Count}");

    foreach (var wall in diff.Data.Walls)
    {
        Console.WriteLine($"Wall at {wall.Seconds:F3}s (beat {wall.Beats:F2})");
        Console.WriteLine($"  Position: ({wall.x}, {wall.y})");
        Console.WriteLine($"  Size: {wall.Width}x{wall.Height}");
        Console.WriteLine($"  Duration: {wall.DurationInSeconds:F3}s ({wall.DurationInBeats:F2} beats)");
        Console.WriteLine($"  NJS: {wall.Njs:F2}");
    }
}
```

--------------------------------

### Accessing Lighting Events in Beatleader Maps

Source: https://context7.com/beatleader/beatleader-parser/llms.txt

Demonstrates how to access various lighting event data in Beatleader maps, including basic lights, V3 light color event box groups, and rotation events. This code requires the beatleader-parser library and shows how to inspect timing, types, values, and group information.

```csharp
using beatleader_parser;
using System.Linq;

var parser = new Parse();
var map = parser.TryLoadPath("/path/to/map");

if (map != null)
{
    var diff = map.Difficulties[0];

    // Basic lights
    Console.WriteLine($"Basic Light Events: {diff.Data.Lights.Count}");
    foreach (var light in diff.Data.Lights.Take(10))
    {
        Console.WriteLine($"Light event at {light.Seconds:F3}s");
        Console.WriteLine($"  Type: {light.Type}, Value: {light.Value}");
        Console.WriteLine($"  Float Value: {light.f}");
    }

    // V3 Light Color Event Box Groups
    Console.WriteLine($"\nLight Color Event Box Groups: {diff.Data.lightColorEventBoxGroups.Count}");
    foreach (var group in diff.Data.lightColorEventBoxGroups.Take(5))
    {
        Console.WriteLine($"Color group at {group.Beats:F2} beats, Group ID: {group.Group}");
        Console.WriteLine($"  Event Boxes: {group.EventBoxGroup.Count}");
    }

    // Rotation events
    Console.WriteLine($"\nRotation Events: {diff.Data.Rotations.Count}");
    foreach (var rotation in diff.Data.Rotations.Take(5))
    {
        Console.WriteLine($"Rotation at {rotation.Seconds:F3}s: {rotation.Rotation}°");
    }
}
```

--------------------------------

### Load Single Beat Saber Difficulty from Path (C#)

Source: https://context7.com/beatleader/beatleader-parser/llms.txt

Loads only a specific difficulty and characteristic of a Beat Saber map from a given folder path. This is efficient when you only need data for a particular playstyle, reducing memory usage and parsing time.

```csharp
using beatleader_parser;

var parser = new Parse();
var singleDiff = parser.TryLoadPath(
    "/path/to/beatmap/folder",
    characteristic: "Standard",
    difficulty: "ExpertPlus"
);

if (singleDiff != null)
{
    var diff = singleDiff.Difficulty;
    Console.WriteLine($"Loaded {diff.Difficulty} - {diff.Characteristic}");
    Console.WriteLine($"Notes: {diff.Data.Notes.Count}");
    Console.WriteLine($"Max NJS: {diff.BeatMap._noteJumpMovementSpeed}");

    // Access timing information
    foreach (var note in diff.Data.Notes.Take(5))
    {
        Console.WriteLine($"Note at {note.Seconds:F3}s, beat {note.Beats:F2}, position ({note.x}, {note.y})");
    }
}
```

--------------------------------

### Loading Beatmap from File Path

Source: https://context7.com/beatleader/beatleader-parser/llms.txt

Load a Beat Saber map directly from a folder containing Info.dat and difficulty files. This method automatically handles version detection and conversion.

```APIDOC
## Loading Beatmap from File Path

Load a Beat Saber map directly from a folder containing Info.dat and difficulty files.

### Method

This is a conceptual representation of the loading process. The actual implementation uses the `Parse.TryLoadPath` method from the `beatleader_parser` library.

### Endpoint

N/A (This is a library function, not a web endpoint.)

### Parameters

N/A

### Request Example

```csharp
using beatleader_parser;
using Parser.Map;

var parser = new Parse();
var map = parser.TryLoadPath("/path/to/beatmap/folder");

if (map != null)
{
    Console.WriteLine($"Loaded: {map.Info._songName}");
    Console.WriteLine($"Song Length: {map.SongLength:F2}s");

    // Access all difficulties
    foreach (var diff in map.Difficulties)
    {
        var noteCount = diff.Data.Notes.Count;
        var njs = diff.BeatMap._noteJumpMovementSpeed;
        Console.WriteLine($"{diff.Difficulty} ({diff.Characteristic}): {noteCount} notes, NJS: {njs}");
    }
}
```

### Response

#### Success Response (Object)

Returns a `Beatmap` object representing the loaded beatmap, or `null` if loading fails.

- **map** (Beatmap) - The loaded `Beatmap` object containing song info, song length, and difficulty data.

#### Response Example

```json
{
  "Info": {
    "_songName": "Song Name",
    "_songAuthorName": "Song Author",
    "_levelAuthorName": "Mapper Name",
    "_beatsPerMinute": 120,
    "_duration": 180.5
  },
  "SongLength": 180.5,
  "Difficulties": [
    {
      "Characteristic": "Standard",
      "Difficulty": "ExpertPlus",
      "Data": {
        "Notes": [...],
        "Bombs": [...],
        "Walls": [...] 
      },
      "BeatMap": {
         "_noteJumpMovementSpeed": 15
      }
    }
  ]
}
```

#### Error Response (Null)

Returns `null` if the specified path is invalid or the beatmap files cannot be parsed.
```

--------------------------------

### Download and Load Beat Saber Map from URL (C#)

Source: https://context7.com/beatleader/beatleader-parser/llms.txt

Downloads a Beat Saber map from a given URL, typically a ZIP archive, and then parses it. This is convenient for automated processing of online beatmaps without manual downloading.

```csharp
using beatleader_parser;

var parser = new Parse();
var maps = parser.TryDownloadLink("https://example.com/beatmap.zip");

if (maps != null && maps.Count > 0)
{
    var map = maps[0];
    Console.WriteLine($"Downloaded: {map.Info._songName}");
    Console.WriteLine($"Available difficulties: {map.Difficulties.Count}");

    foreach (var diff in map.Difficulties)
    {
        Console.WriteLine($"  {diff.Characteristic}/{diff.Difficulty}: {diff.Data.Notes.Count} notes");
    }
}
else
{
    Console.WriteLine("Failed to download or parse beatmap");
}
```

--------------------------------

### Loading Single Difficulty from File Path

Source: https://context7.com/beatleader/beatleader-parser/llms.txt

Load only a specific difficulty and characteristic from a beatmap folder. Useful for optimizing load times when only a particular version of a map is needed.

```APIDOC
## Loading Single Difficulty from File Path

Load only a specific difficulty and characteristic from a map folder.

### Method

This is a conceptual representation of the loading process. The actual implementation uses the `Parse.TryLoadPath` method with optional `characteristic` and `difficulty` parameters from the `beatleader_parser` library.

### Endpoint

N/A (This is a library function, not a web endpoint.)

### Parameters

N/A

### Request Example

```csharp
using beatleader_parser;

var parser = new Parse();
var singleDiff = parser.TryLoadPath(
    "/path/to/beatmap/folder",
    characteristic: "Standard",
    difficulty: "ExpertPlus"
);

if (singleDiff != null)
{
    var diff = singleDiff.Difficulty;
    Console.WriteLine($"Loaded {diff.Difficulty} - {diff.Characteristic}");
    Console.WriteLine($"Notes: {diff.Data.Notes.Count}");
    Console.WriteLine($"Max NJS: {diff.BeatMap._noteJumpMovementSpeed}");

    // Access timing information
    foreach (var note in diff.Data.Notes.Take(5))
    {
        Console.WriteLine($"Note at {note.Seconds:F3}s, beat {note.Beats:F2}, position ({note.x}, {note.y})");
    }
}
```

### Response

#### Success Response (Object)

Returns a `Beatmap` object containing only the specified difficulty, or `null` if loading fails.

- **singleDiff** (Beatmap) - The loaded `Beatmap` object with a single difficulty.

#### Response Example

```json
{
  "Info": {
    "_songName": "Song Name",
    "_songAuthorName": "Song Author",
    "_levelAuthorName": "Mapper Name",
    "_beatsPerMinute": 120,
    "_duration": 180.5
  },
  "SongLength": 180.5,
  "Difficulties": [
    {
      "Characteristic": "Standard",
      "Difficulty": "ExpertPlus",
      "Data": {
        "Notes": [...],
        "Bombs": [...],
        "Walls": [...] 
      },
      "BeatMap": {
         "_noteJumpMovementSpeed": 15
      }
    }
  ]
}
```

#### Error Response (Null)

Returns `null` if the specified path, characteristic, or difficulty is invalid, or if the beatmap files cannot be parsed.
```

--------------------------------

### Loading Beatmap from URL

Source: https://context7.com/beatleader/beatleader-parser/llms.txt

Download and parse a Beat Saber map directly from a URL. The library handles the download process and subsequent parsing of the beatmap data.

```APIDOC
## Loading Beatmap from URL

Download and parse a Beat Saber map directly from a URL.

### Method

This is a conceptual representation of the loading process. The actual implementation uses the `Parse.TryDownloadLink` method from the `beatleader_parser` library.

### Endpoint

N/A (This is a library function, not a web endpoint.)

### Parameters

N/A

### Request Example

```csharp
using beatleader_parser;

var parser = new Parse();
var maps = parser.TryDownloadLink("https://example.com/beatmap.zip");

if (maps != null && maps.Count > 0)
{
    var map = maps[0];
    Console.WriteLine($"Downloaded: {map.Info._songName}");
    Console.WriteLine($"Available difficulties: {map.Difficulties.Count}");

    foreach (var diff in map.Difficulties)
    {
        Console.WriteLine($"  {diff.Characteristic}/{diff.Difficulty}: {diff.Data.Notes.Count} notes");
    }
}
else
{
    Console.WriteLine("Failed to download or parse beatmap");
}
```

### Response

#### Success Response (List<Beatmap>)

Returns a list of `Beatmap` objects if the download and parsing are successful. Each object represents a beatmap with its associated difficulties.

- **maps** (List<Beatmap>) - A list containing one or more `Beatmap` objects.

#### Response Example

```json
{
  "maps": [
    {
      "Info": {
        "_songName": "Song Name",
        "_songAuthorName": "Song Author",
        "_levelAuthorName": "Mapper Name",
        "_beatsPerMinute": 120,
        "_duration": 180.5
      },
      "SongLength": 180.5,
      "Difficulties": [
        {
          "Characteristic": "Standard",
          "Difficulty": "ExpertPlus",
          "Data": {
            "Notes": [...],
            "Bombs": [...],
            "Walls": [...] 
          },
          "BeatMap": {
             "_noteJumpMovementSpeed": 15
          }
        }
      ]
    }
  ]
}
```

#### Error Response (Null)

Returns `null` if the URL is invalid, the download fails, or the beatmap data cannot be parsed.
```

--------------------------------

### Access Beatmap Note Timing and Spatial Data

Source: https://context7.com/beatleader/beatleader-parser/llms.txt

Provides access to detailed information about each note in a beatmap, including its timing (beat and second), spatial coordinates (x, y), color, cut direction, and angle offset. It also shows how to access custom data if present.

```csharp
using beatleader_parser;
using Parser.Map.Difficulty.V3.Grid;

var parser = new Parse();
var map = parser.TryLoadPath("/path/to/map");

if (map != null)
{
    var expertPlus = map.Difficulties.Find(d => d.Difficulty == "ExpertPlus");
    if (expertPlus != null)
    {
        foreach (var note in expertPlus.Data.Notes)
        {
            // Timing information
            Console.WriteLine($"Note at beat {note.Beats:F2} ({note.Seconds:F3}s)");

            // Spatial data
            Console.WriteLine($"  Position: ({note.x}, {note.y})");
            Console.WriteLine($"  Color: {(note.Color == 0 ? "Red" : note.Color == 1 ? "Blue" : "Other")}");
            Console.WriteLine($"  Cut Direction: {(Note.Direction)note.CutDirection}");
            Console.WriteLine($"  Angle Offset: {note.AngleOffset}°");

            // Custom data if present
            if (note.customData?.coordinates != null)
            {
                Console.WriteLine($"  Custom Position: ({note.customData.coordinates[0]}, {note.customData.coordinates[1]})");
            }
        }
    }
}
```

--------------------------------

### Loading Beatmap from ZIP Archive

Source: https://context7.com/beatleader/beatleader-parser/llms.txt

Parse a Beat Saber map from a ZIP file in memory. The library automatically detects and converts between V2, V3, and V4 formats.

```APIDOC
## Loading Beatmap from ZIP Archive

Parse a Beat Saber map from a ZIP file in memory, automatically detecting and converting between V2, V3, and V4 formats.

### Method

This is a conceptual representation of the loading process. The actual implementation uses the `Parse.TryLoadZip` method from the `beatleader_parser` library.

### Endpoint

N/A (This is a library function, not a web endpoint.)

### Parameters

N/A

### Request Example

```csharp
using beatleader_parser;
using System.IO;

// Load ZIP file into memory
var zipBytes = File.ReadAllBytes("path/to/beatmap.zip");
var memoryStream = new MemoryStream(zipBytes);

// Parse the map
var parser = new Parse();
var beatmaps = parser.TryLoadZip(memoryStream);

if (beatmaps != null && beatmaps.Count > 0)
{
    var map = beatmaps[0];
    Console.WriteLine($"Song: {map.Info._songName} by {map.Info._songAuthorName}");
    Console.WriteLine($"Mapper: {map.Info._levelAuthorName}");
    Console.WriteLine($"BPM: {map.Info._beatsPerMinute}");
    Console.WriteLine($"Duration: {map.SongLength:F2} seconds");

    foreach (var difficulty in map.Difficulties)
    {
        Console.WriteLine($"  {difficulty.Characteristic} - {difficulty.Difficulty}");
        Console.WriteLine($"    Notes: {difficulty.Data.Notes.Count}");
        Console.WriteLine($"    Bombs: {difficulty.Data.Bombs.Count}");
        Console.WriteLine($"    Walls: {difficulty.Data.Walls.Count}");
    }
}
else
{
    Console.WriteLine("Failed to load beatmap");
}
```

### Response

#### Success Response (Object)

Returns a list of `Beatmap` objects, where each object represents a beatmap with its associated difficulties.

- **beatmaps** (List<Beatmap>) - A list containing one or more `Beatmap` objects if parsing is successful.

#### Response Example

```json
{
  "beatmaps": [
    {
      "Info": {
        "_songName": "Song Name",
        "_songAuthorName": "Song Author",
        "_levelAuthorName": "Mapper Name",
        "_beatsPerMinute": 120,
        "_duration": 180.5
      },
      "SongLength": 180.5,
      "Difficulties": [
        {
          "Characteristic": "Standard",
          "Difficulty": "ExpertPlus",
          "Data": {
            "Notes": [...],
            "Bombs": [...],
            "Walls": [...] 
          },
          "BeatMap": {
             "_noteJumpMovementSpeed": 15
          }
        }
      ]
    }
  ]
}
```

#### Error Response (Null)

Returns `null` if the ZIP file is invalid or cannot be parsed.
```

--------------------------------

### Load Beat Saber Map from File Path (C#)

Source: https://context7.com/beatleader/beatleader-parser/llms.txt

Loads a Beat Saber map directly from a specified folder path containing 'Info.dat' and difficulty files. This method is suitable for parsing maps that have already been extracted or are stored locally on disk.

```csharp
using beatleader_parser;
using Parser.Map;

var parser = new Parse();
var map = parser.TryLoadPath("/path/to/beatmap/folder");

if (map != null)
{
    Console.WriteLine($"Loaded: {map.Info._songName}");
    Console.WriteLine($"Song Length: {map.SongLength:F2}s");

    // Access all difficulties
    foreach (var diff in map.Difficulties)
    {
        var noteCount = diff.Data.Notes.Count;
        var njs = diff.BeatMap._noteJumpMovementSpeed;
        Console.WriteLine($"{diff.Difficulty} ({diff.Characteristic}): {noteCount} notes, NJS: {njs}");
    }
}
```

--------------------------------

### Load Beat Saber Map from ZIP Archive (C#)

Source: https://context7.com/beatleader/beatleader-parser/llms.txt

Parses a Beat Saber map from a ZIP file in memory. It automatically detects and converts between V2, V3, and V4 formats, returning a list of beatmaps. Useful for processing beatmaps without extracting them to disk.

```csharp
using beatleader_parser;
using System.IO;

// Load ZIP file into memory
var zipBytes = File.ReadAllBytes("path/to/beatmap.zip");
var memoryStream = new MemoryStream(zipBytes);

// Parse the map
var parser = new Parse();
var beatmaps = parser.TryLoadZip(memoryStream);

if (beatmaps != null && beatmaps.Count > 0)
{
    var map = beatmaps[0];
    Console.WriteLine($"Song: {map.Info._songName} by {map.Info._songAuthorName}");
    Console.WriteLine($"Mapper: {map.Info._levelAuthorName}");
    Console.WriteLine($"BPM: {map.Info._beatsPerMinute}");
    Console.WriteLine($"Duration: {map.SongLength:F2} seconds");

    foreach (var difficulty in map.Difficulties)
    {
        Console.WriteLine($"  {difficulty.Characteristic} - {difficulty.Difficulty}");
        Console.WriteLine($"    Notes: {difficulty.Data.Notes.Count}");
        Console.WriteLine($"    Bombs: {difficulty.Data.Bombs.Count}");
        Console.WriteLine($"    Walls: {difficulty.Data.Walls.Count}");
    }
}
else
{
    Console.WriteLine("Failed to load beatmap");
}
```

--------------------------------

### Accessing Chains (Burst Sliders) in Beatleader Maps

Source: https://context7.com/beatleader/beatleader-parser/llms.txt

Shows how to retrieve and display data for chains (burst sliders) from a Beatleader map. Includes information on start/end times, positions, slice count, squish factor, color, and direction. Requires the beatleader-parser library.

```csharp
using beatleader_parser;

var parser = new Parse();
var map = parser.TryLoadPath("/path/to/map");

if (map != null)
{
    var diff = map.Difficulties[0];

    Console.WriteLine($"Chains: {diff.Data.Chains.Count}");

    foreach (var chain in diff.Data.Chains)
    {
        Console.WriteLine($"Chain from {chain.Seconds:F3}s to {chain.TailInSeconds:F3}s");
        Console.WriteLine($"  Head: ({chain.x}, {chain.y})");
        Console.WriteLine($"  Tail: ({chain.tx}, {chain.ty})");
        Console.WriteLine($"  Slice Count: {chain.SliceCount}");
        Console.WriteLine($"  Squish Factor: {chain.Squish}");
        Console.WriteLine($"  Color: {chain.Color}, Direction: {chain.CutDirection}");
    }
}
```

--------------------------------

### Accessing BPM Events in Beatleader Maps

Source: https://context7.com/beatleader/beatleader-parser/llms.txt

Illustrates how to work with tempo (BPM) changes within a Beatleader map. The code shows how to detect and display BPM events, including their timing and new BPM value, or the default BPM if no changes exist. Requires the beatleader-parser library.

```csharp
using beatleader_parser;

var parser = new Parse();
var map = parser.TryLoadPath("/path/to/map");

if (map != null)
{
    var diff = map.Difficulties[0];

    if (diff.Data.bpmEvents.Count > 0)
    {
        Console.WriteLine($"BPM Changes: {diff.Data.bpmEvents.Count}");

        foreach (var bpmEvent in diff.Data.bpmEvents)
        {
            Console.WriteLine($"BPM change at {bpmEvent.Seconds:F3}s (beat {bpmEvent.Beats:F2})");
            Console.WriteLine($"  New BPM: {bpmEvent.Bpm:F2}");
            Console.WriteLine($"  Start Time: {bpmEvent.BpmChangeStartTime:F3}s");
        }
    }
    else
    {
        Console.WriteLine($"Single BPM: {map.Info._beatsPerMinute}");
    }
}
```

--------------------------------

### Mirror Beatmap for Left-Handed Play

Source: https://context7.com/beatleader/beatleader-parser/llms.txt

Mirrors an entire beatmap or a specific difficulty to swap colors and horizontal positions, making it suitable for left-handed players. This operation modifies the map data in place.

```csharp
using Parser.Utils;
using beatleader_parser;

var parser = new Parse();
var map = parser.TryLoadPath("/path/to/map");

if (map != null)
{
    // Mirror entire map (all difficulties)
    map.Mirror();

    Console.WriteLine("Mirrored entire map");

    // Verify mirroring by checking first note
    var firstNote = map.Difficulties[0].Data.Notes[0];
    Console.WriteLine($"First note - Color: {firstNote.Color}, X: {firstNote.x}, Direction: {firstNote.CutDirection}");
}

// Or mirror just one difficulty
var singleDiff = parser.TryLoadPath("/path/to/map", "Standard", "Expert");
if (singleDiff != null)
{
    singleDiff.Difficulty.Mirror();
    Console.WriteLine("Mirrored single difficulty");
}
```

--------------------------------

### Calculate Maximum Score for a Difficulty

Source: https://context7.com/beatleader/beatleader-parser/llms.txt

Calculates the maximum achievable score for a specific beatmap difficulty, taking into account the proper multiplier progression. It also provides a score graph over time and allows querying the score at specific timestamps.

```csharp
using Parser.Utils;
using beatleader_parser;

var parser = new Parse();
var map = parser.TryLoadPath("/path/to/map");

if (map != null)
{
    foreach (var diff in map.Difficulties)
    {
        int maxScore = diff.MaxScore();
        Console.WriteLine($"{diff.Difficulty}: Max Score = {maxScore:N0}");

        // Get score graph over time
        var scoreGraph = diff.MaxScoreGraph();
        Console.WriteLine($"  Score progression points: {scoreGraph.Count}");

        // Show score at specific timestamps
        foreach (var (time, score) in scoreGraph.Where((_, i) => i % 100 == 0))
        {
            Console.WriteLine($"    At {time:F2}s: {score:N0}");
        }
    }
}
```

--------------------------------

### Load Beatmap from JSON Strings

Source: https://context7.com/beatleader/beatleader-parser/llms.txt

Parses Beatmap data from in-memory JSON strings. This method is useful when the beatmap data is already loaded into strings and the song's duration is known. It returns a list of parsed Beatmap objects.

```csharp
using beatleader_parser;
using System.Collections.Generic;

var jsonData = new List<(string filename, string json)>
{
    ("Info.dat", infoJsonString),
    ("ExpertPlusStandard.dat", expertPlusJsonString),
    ("ExpertStandard.dat", expertJsonString)
};

var parser = new Parse();
var maps = parser.TryLoadString(jsonData, songLength: 180.5f);

if (maps != null && maps.Count > 0)
{
    var map = maps[0];
    Console.WriteLine($"Parsed from strings: {map.Info._songName}");
    Console.WriteLine($"Difficulties loaded: {map.Difficulties.Count}");
}
```

--------------------------------

### Detect V3 Pepega Maps with Overlapping Objects

Source: https://context7.com/beatleader/beatleader-parser/llms.txt

Checks if a beatmap difficulty uses overlapping V3 objects (arcs/chains on notes) that can affect scoring. This function returns a boolean indicating whether such overlaps are present.

```csharp
using Parser.Utils;
using beatleader_parser;

var parser = new Parse();
var map = parser.TryLoadPath("/path/to/map");

if (map != null)
{
    foreach (var diff in map.Difficulties)
    {
        bool isPepega = diff.IsV3Pepega();
        if (isPepega)
        {
            Console.WriteLine($"{diff.Difficulty}: Contains overlapping V3 scoring objects");
            Console.WriteLine("  This map has notes that overlap with arc/chain heads or tails");
        }
        else
        {
            Console.WriteLine($"{diff.Difficulty}: Standard scoring");
        }
    }
}
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.