Index

Modules: rconv/common, rconv/fxf, rconv/malody, rconv/mapper, rconv/memo, rconv/memson, rconv/pipeline, rconv/private/json_helpers, rconv/private/line_reader, rconv/private/simfile_common, rconv/private/simfile_helper, rconv/private/stream_helpers, rconv/private/utils, rconv/step_mania.

API symbols

`$`:

• simfile_common: `$`(ct: ChartType): string
• simfile_common: `$`(diff: Difficulty): string

asFormattingParams:

• fxf: asFormattingParams(chart: ChartFile): FormattingParameters
• malody: asFormattingParams(chart: Chart): FormattingParameters
• step_mania: asFormattingParams(chart: ChartFile): FormattingParameters

Attack:

• simfile_common: Attack

BackgroundChange:

• simfile_common: BackgroundChange

Beat:

• malody: Beat
• step_mania: Beat

boolFlag:

• simfile_common: boolFlag(val: bool): string

BpmChange:

• fxf: BpmChange
• simfile_common: BpmChange

BpmRange:

• memson: BpmRange

Chart:

• fxf: Chart
• malody: Chart

ChartCollection:

• fxf: ChartCollection

ChartFile:

• fxf: ChartFile
• step_mania: ChartFile

ChartMode:

• malody: ChartMode

ChartType:

• simfile_common: ChartType

col:

• line_reader: col(this: LineReaderRef): int

Color:

• simfile_common: Color

columnCount:

• simfile_common: columnCount(mode: ChartType): int

CombinedError:

• common: CombinedError

ComboChange:

• simfile_common: ComboChange

convert:

• pipeline: convert(file: string; fromType: Option[FileType]; to: FileType; options: Option[ConvertOptions]): ConvertResult

ConvertException:

• common: ConvertException

ConvertOptions:

• common: ConvertOptions

ConvertResult:

• common: ConvertResult

DefaultChartFormat:

• common: DefaultChartFormat

DefaultFolderFormat:

• common: DefaultFolderFormat

DefaultNonDifficultyChartFormat:

• common: DefaultNonDifficultyChartFormat

Delay:

• simfile_common: Delay

detectFileType:

• common: detectFileType(file: string): Option[FileType]

Difficulty:

• memson: Difficulty
• simfile_common: Difficulty

ElementType:

• malody: ElementType

EmptyBeat:

• malody: EmptyBeat

existsOrCreateDirRecursive:

• utils: existsOrCreateDirRecursive(path: string): void

ExtraData:

• malody: ExtraData

ExtraTestData:

• malody: ExtraTestData

FakeSection:

• simfile_common: FakeSection

FileType:

• common: FileType

find:

• utils: find[T](collection: seq[T]; fn: proc (element: T): bool; start: int = 0): int

formatFileName:

• common: formatFileName(this: ConvertOptions; params: FormattingParameters): string

formatFolderName:

• common: formatFolderName(this: ConvertOptions; params: FormattingParameters): string

FormattingParameters:

• common: FormattingParameters

getCatchNoteType:

• malody: getCatchNoteType(id: int): CatchNoteType

getDefaultChartFormat:

• common: getDefaultChartFormat(fileType: FileType): string

getDefaultOptions:

• common: getDefaultOptions(to: FileType): ConvertOptions

getFileExtension:

• common: getFileExtension(fileType: FileType): string

getFloatSafe:

• json_helpers: getFloatSafe(self: JsonNode; field: string; default: float = 0.0): float

getIntSafe:

• json_helpers: getIntSafe(self: JsonNode; field: string; default: int = 0): int

getPriority:

• malody: getPriority(this: TimedElement): int

getSlideNoteType:

• malody: getSlideNoteType(id: int): SlideNoteType

getSoundCueType:

• malody: getSoundCueType(id: int): SoundCueType

getStringSafe:

• json_helpers: getStringSafe(self: JsonNode; field: string; default: string = ""): string

hasField:

• json_helpers: hasField(self: JsonNode; field: string; kind: JsonNodeKind): bool

Hold:

• fxf: Hold

HoldType:

• malody: HoldType

InstrumentTrack:

• simfile_common: InstrumentTrack

InvalidModeException:

• malody: InvalidModeException

InvalidNoteError:

• step_mania: InvalidNoteError

InvalidTypeException:

• common: InvalidTypeException

InvalidVersionException:

• fxf: InvalidVersionException

isEOF:

• line_reader: isEOF(this: LineReaderRef): bool

Label:

• simfile_common: Label

last:

• utils: last[T](collection: seq[T]): T

line:

• line_reader: line(this: LineReaderRef): int

LineReader:

• line_reader: LineReader

LineReaderRef:

• line_reader: LineReaderRef

Memson:

• memson: Memson

MetaData:

• malody: MetaData

MissingConversionException:

• common: MissingConversionException

MissingTypeException:

• common: MissingTypeException

ModeData:

• malody: ModeData

Modifier:

• simfile_common: Modifier

newAttack:

• simfile_common: newAttack(length: float = 0.0; mods: seq[string] = @[]): Attack

newBackgroundChange:

• simfile_common: newBackgroundChange(beat: float = 0.0; path: string = ""; updateRate: float = 0.0; crossFade: bool = false; stretchRewind: bool = false; stretchNoLoop: bool = false; effect: string = ""; file2: string = ""; transition: string = ""; color1: Color = [0.0, 0.0, 0.0, 0.0]; color2: Color = [0.0, 0.0, 0.0, 0.0]): BackgroundChange

newBeat:

• step_mania: newBeat(index: int; snapSize: int = 0; notes: seq[Note] = @[]): Beat

newBpmChange:

• fxf: newBpmChange(bpm: float32 = 0; time: float32 = 0; snapSize: uint16 = 0; snapIndex: uint16 = 0): BpmChange
• simfile_common: newBpmChange(beat: float; bpm: float): BpmChange
• simfile_common: newBpmChange(beat: Option[float]; bpm: Option[float]): BpmChange

newCatchHold:

• malody: newCatchHold(beat: Beat = EmptyBeat; x: int = 0; type: CatchNoteType = CatchNoteType.Hold; endBeat: Beat = EmptyBeat): TimedElement

newCatchNote:

• malody: newCatchNote(beat: Beat = EmptyBeat; x: int = 0; type: CatchNoteType = CatchNoteType.Hold): TimedElement

newChart:

• fxf: newChart(rating: uint32 = 1; ticks: seq[Tick] = @[]): Chart
• malody: newChart(meta: MetaData = newMetaData(); time: seq[TimedElement] = @[]; note: seq[TimedElement] = @[]): Chart

newChartCollection:

• fxf: newChartCollection(basic: Chart = nil; advanced: Chart = nil; extreme: Chart = nil): ChartCollection

newChartFile:

• fxf: newChartFile(title: string = ""; artist: string = ""; audio: string = ""; jacket: string = ""; offset: int32 = 0; bpmChange: seq[BpmChange] = @[]; charts = newChartCollection()): ChartFile
• step_mania: newChartFile(title: string = ""; subtitle: string = ""; arist: string = ""; titleTransliterated: string = ""; subtitleTransliterated: string = ""; artistTransliterated: string = ""; genre: string = ""; credit: string = ""; banner: string = ""; background: string = ""; lyricsPath: string = ""; cdTitle: string = ""; music: string = ""; instrumentTracks: seq[InstrumentTrack] = @[]; sampleStart: float = 0.0; sampleLength: float = 0.0; displayBpm: string = ""; selectable: bool = true; bgChanges: seq[BackgroundChange] = @[]; bgChanges2: seq[BackgroundChange] = @[]; bgChanges3: seq[BackgroundChange] = @[]; animations: seq[BackgroundChange] = @[]; fgChanges: seq[BackgroundChange] = @[]; keySounds: seq[string] = @[]; offset: float = 0.0; stops: seq[Stop] = @[]; bpms: seq[BpmChange] = @[]; timeSignatures: seq[TimeSignature] = @[]; attacks: seq[TimedAttack] = @[]; delays: seq[Delay] = @[]; tickCounts: seq[TickCount] = @[]; noteData: seq[NoteData] = @[]; combos: seq[ComboChange] = @[]; speeds: seq[SpeedChange] = @[]; scrolls: seq[ScollSpeedChange] = @[]; fakes: seq[FakeSection] = @[]; labels: seq[Label] = @[]): ChartFile

newColumnHold:

• malody: newColumnHold(beat: Beat = EmptyBeat; column: KeyColumnRange = 0; style: int = 0; endBeat: Beat = EmptyBeat; hits: int = 1): TimedElement

newColumnNote:

• malody: newColumnNote(beat: Beat = EmptyBeat; column: KeyColumnRange = 0; style: int = 0): TimedElement

newComboChange:

• simfile_common: newComboChange(beat: float; hit: int; miss: int): ComboChange
• simfile_common: newComboChange(beat: Option[float]; hit: Option[int]; miss: Option[int]): ComboChange

newConvertOptions:

• common: newConvertOptions(bundle: bool = false; songFolders: bool = false; jsonPretty: bool = false; keep: bool = false; merge: bool = false; output: string = "."; preserve: bool = false; resources: bool = false; normalize: bool = false; folderFormat: string = DefaultFolderFormat; chartFormat: string = ""): ConvertOptions

newDelay:

• simfile_common: newDelay(beat: float; duration: float): Delay
• simfile_common: newDelay(beat: Option[float]; duration: Option[float]): Delay

newFakeSection:

• simfile_common: newFakeSection(beat: float; duration: float): FakeSection
• simfile_common: newFakeSection(beat: Option[float]; duration: Option[float]): FakeSection

newFormattingParameters:

• common: newFormattingParameters(title: string = "untitled"; artist: string = "unknown"; difficulty: string = "edit"; level: string = ""; mode: string = ""; extension: string = "txt"): FormattingParameters

newHold:

• fxf: newHold(from: NoteRange; to: NoteRange; releaseOn: float32 = 0): Hold
• memson: newHold(time: int = 0; partIndex: int = 0; animationStartIndex: int = 0; releaseTime: int = 0; releasePart: int = 0; releaseSection: int = 1): Note

newIndexHold:

• malody: newIndexHold(beat: Beat = EmptyBeat; index: IndexRange; endBeat: Beat = EmptyBeat; endIndex: IndexRange): TimedElement

newIndexNote:

• malody: newIndexNote(beat: Beat = EmptyBeat; index: IndexRange = 0): TimedElement

newInstrumentTrack:

• simfile_common: newInstrumentTrack(instrument: string = ""; file: string = ""): InstrumentTrack

newLabel:

• simfile_common: newLabel(beat: float = 0.0; content: string = ""): Label

newLineReader:

• line_reader: newLineReader(str: string): LineReaderRef

newMemson:

• memson: newMemson(songTitle: string = ""; artist: string = ""; difficulty: Difficulty = Difficulty.Basic; level: int = 1; bpm: float = 0.0; bpmRange: BpmRange; sections: seq[Section] = @[]): Memson

newMetaData:

• malody: newMetaData($ver: int = 1; creator: string = ""; background: string = ""; version: string = ""; preview: int = 0; id: uint = 0; mode: ChartMode = ChartMode.Key; time: int = 0; song: SongData = newSongData(); mode_ext: ModeData = newModeData()): MetaData

newModeData:

• malody: newModeData(column: int = 0; bar_begin: int = 0; speed: int = 0): ModeData

newModifier:

• simfile_common: newModifier(name: string; player: string = ""; approachRate: int = 1; magnitude: float = 100; isPercent: bool = true): Modifier

newNote:

• memson: newNote(time: int = 0; partIndex: int = 0): Note
• step_mania: newNote(kind: NoteType; snap: int; column: int; attack: Attack = nil; keySound: int = -1): Note

newNoteData:

• step_mania: newNoteData(chartType: ChartType; description: string = ""; difficulty: Difficulty = Difficulty.Beginner; difficultyLevel: int = 1; beats: seq[Beat] = @[]): NoteData

newScollSpeedChange:

• simfile_common: newScollSpeedChange(beat: float; factor: float): ScollSpeedChange
• simfile_common: newScollSpeedChange(beat: Option[float]; factor: Option[float]): ScollSpeedChange

newSection:

• memson: newSection(index: int = 1; bpm: float = 0.0; partCount: int = 1; timings: seq[int] = @[]; snaps: seq[Snap] = @[]; noteCount: uint = 0; notes: OrderedTable[NoteRange, seq[Note]] = initOrderedTable()): Section

newSlideNote:

• malody: newSlideNote(beat: Beat = EmptyBeat; x: int = 0; width: int = 0; type: SlideNoteType = SlideNoteType.Hold; segments: seq[TimedElement] = @[]): TimedElement

newSnap:

• memson: newSnap(length: int = 1; partIndex: int = 0; row = 0): Snap

newSongData:

• malody: newSongData(title: string = ""; titleorg: string = ""; artist: string = ""; artistorg: string = ""; id: int = 0): SongData

newSoundCue:

• malody: newSoundCue(beat: Beat = EmptyBeat; type: SoundCueType = SoundCueType.Effect; sound: string = ""; offset: float = 0; volume: float = 0): TimedElement

newSpeedChange:

• simfile_common: newSpeedChange(beat: float; ratio: float; duration: float; inSeconds: bool): SpeedChange
• simfile_common: newSpeedChange(beat: Option[float]; ratio: Option[float]; duration: Option[float]; inSeconds: Option[bool]): SpeedChange

newStop:

• simfile_common: newStop(beat: float; duration: float): Stop
• simfile_common: newStop(beat: Option[float]; duration: Option[float]): Stop

newTick:

• fxf: newTick(time: float32 = 0; snapSize: uint16 = 0; snapIndex: uint16 = 0; notes: seq[uint8] = @[]; holds: seq[Hold] = @[]): Tick

newTickCount:

• simfile_common: newTickCount(beat: float; count: int): TickCount
• simfile_common: newTickCount(beat: Option[float]; count: Option[int]): TickCount

newTimedAttack:

• step_mania: newTimedAttack(time: float; length: float; mods: seq[Modifier] = @[]): TimedAttack
• step_mania: newTimedAttack(time: Option[float]; length: Option[float]; mods: seq[Modifier] = @[]): TimedAttack

newTimedElement:

• malody: newTimedElement(beat: Beat = EmptyBeat): TimedElement

newTimeSignature:

• malody: newTimeSignature(beat: Beat = EmptyBeat; bpm: float = 0): TimedElement
• simfile_common: newTimeSignature(beat: float; numerator: int; denominator: int): TimeSignature
• simfile_common: newTimeSignature(beat: Option[float]; numerator: Option[int]; denominator: Option[int]): TimeSignature

nextLine:

• line_reader: nextLine(this: LineReaderRef): string

Note:

• memson: Note
• step_mania: Note

NoteData:

• step_mania: NoteData

NoteRange:

• fxf: NoteRange
• memson: NoteRange

NoteType:

• memson: NoteType
• step_mania: NoteType

OneMinute:

• common: OneMinute

parseAttack:

• simfile_common: parseAttack(data: string): Attack

parseBackgroundChanges:

• simfile_common: parseBackgroundChanges(data: string): seq[BackgroundChange]

parseBoolSafe:

• utils: parseBoolSafe(value: string; default: Option[bool] = none[bool]()): Option[bool]

parseBpms:

• simfile_common: parseBpms(data: string): seq[BpmChange]

parseColor:

• simfile_common: parseColor(data: string): Color

parseComboChanges:

• simfile_common: parseComboChanges(data: string): seq[ComboChange]

parseDelays:

• simfile_common: parseDelays(data: string): seq[Delay]

parseDifficulty:

• memson: parseDifficulty(input: string): Difficulty

ParseError:

• common: ParseError

parseFakeSections:

• simfile_common: parseFakeSections(data: string): seq[FakeSection]

parseFloatSafe:

• utils: parseFloatSafe(value: string; default: Option[float] = none[float]()): Option[ float]

parseFXF:

• fxf: parseFXF(stream: Stream; lenient: bool = false): ChartFile

parseIntrumentTracks:

• simfile_common: parseIntrumentTracks(data: string): seq[InstrumentTrack]

parseIntSafe:

• utils: parseIntSafe(value: string; default: Option[int] = none[int]()): Option[int]

parseLabels:

• simfile_common: parseLabels(data: string): seq[Label]

parseMalody:

• malody: parseMalody(stream: Stream; lenient: bool = false): Chart
• malody: parseMalody(data: string; lenient: bool = false): Chart

parseMemo:

• memo: parseMemo(content: string): Memson

parseModifier:

• simfile_common: parseModifier(data: string): Modifier

parseRadarValues:

• simfile_common: parseRadarValues(data: string): RadarValues

parseScollSpeedChanges:

• simfile_common: parseScollSpeedChanges(data: string): seq[ScollSpeedChange]

parseSpeedChanges:

• simfile_common: parseSpeedChanges(data: string): seq[SpeedChange]

parseStepMania:

• step_mania: parseStepMania(stream: Stream; lenient: bool = false): ChartFile
• step_mania: parseStepMania(data: string; lenient: bool = false): ChartFile

parseStops:

• simfile_common: parseStops(data: string): seq[Stop]

parseTags:

• simfile_helper: parseTags(data: string): Tag

parseTickCounts:

• simfile_common: parseTickCounts(data: string): seq[TickCount]

parseTimeSignatures:

• simfile_common: parseTimeSignatures(data: string): seq[TimeSignature]

PlaceholderArtist:

• common: PlaceholderArtist

PlaceholderDifficulty:

• common: PlaceholderDifficulty

PlaceholderLevel:

• common: PlaceholderLevel

PlaceholderMode:

• common: PlaceholderMode

PlaceholderTitle:

• common: PlaceholderTitle

PreserveFileException:

• common: PreserveFileException

putTag:

• simfile_common: putTag(str: var string; tag: string; value: string): void

RadarValues:

• simfile_common: RadarValues

readUTF8Str:

• stream_helpers: readUTF8Str(stream: Stream): string

reset:

• line_reader: reset(this: LineReaderRef): void

RowIndex:

• memson: RowIndex

ScollSpeedChange:

• simfile_common: ScollSpeedChange

Section:

• memson: Section

SlideNoteType:

• malody: SlideNoteType

Snap:

• memson: Snap

SongData:

• malody: SongData

SoundCueType:

• malody: SoundCueType

SpeedChange:

• simfile_common: SpeedChange

splitByComma:

• simfile_common: splitByComma(data: string; doStrip: bool = false): seq[string]

splitMin:

• utils: splitMin(str: string; sep: string; minCount: int; default: string = ""): seq[ string]

Stop:

• simfile_common: Stop

stripSplit:

• utils: stripSplit(str: string; sep: string; maxSplit: int = -1): seq[string]

stripSplitMin:

• utils: stripSplitMin(str: string; sep: string; minCount: int; default: string = ""): seq[ string]

Tick:

• fxf: Tick

TickCount:

• simfile_common: TickCount

TimedAttack:

• simfile_common: TimedAttack

TimedElement:

• malody: TimedElement

TimeSignature:

• simfile_common: TimeSignature

toChart:

• malody: toChart(self: JsonNode; lenient: bool = false): Chart

toFXF:

• mapper: toFXF(this: memson.Memson): fxf.ChartFile
• mapper: toFXF(this: malody.Chart): fxf.ChartFile

toJsonHook:

• malody: toJsonHook[T: Chart](this: T): JsonNode
• malody: toJsonHook[T: TimedElement](this: T): JsonNode
• malody: toJsonHook[T: Beat](this: T): JsonNode

toMalody:

• mapper: toMalody(this: memson.Memson): malody.Chart
• mapper: toMalody(chart: sm.ChartFile; index: int = 0): malody.Chart
• mapper: toMalody(chart: sm.ChartFile; notes: NoteData): malody.Chart

toStepMania:

• mapper: toStepMania(chart: malody.Chart): sm.ChartFile

toString:

• stream_helpers: toString(bytes: seq[byte]): string

toTimedElement:

• malody: toTimedElement(self: JsonNode; lenient: bool = false): TimedElement

unshift:

• utils: unshift[T](collection: var seq[T]): T

Version1:

• fxf: Version1

write:

• fxf: write(chart: ChartFile; stream: Stream): void
• malody: write(chart: Chart; pretty: bool = false): string
• malody: write(chart: Chart; stream: Stream; pretty: bool = false): void
• memo: write(chart: Memson): string
• memo: write(chart: Memson; stream: Stream): void
• simfile_common: write(change: BackgroundChange): string
• simfile_common: write(color: Color): string
• simfile_common: write(modi: Modifier): string
• simfile_common: write(attack: TimedAttack): string
• step_mania: write(chart: ChartFile): string
• step_mania: write(chart: ChartFile; stream: Stream): void

writeUTF8:

• stream_helpers: writeUTF8(stream: Stream; strings: varargs[string]): void