🥮 mooncakes.io

moonpixelanimkit

MoonBit-native pixel animation asset parser, validator, runtime model, and export toolkit.

aseprite
sprite
animation
pixel-art
game-dev
moonbit
moon add WangYF0829/moonpixelanimkit@0.1.1
Download zip
Version
0.1.1
License
MIT
Repository
Last updated
17 days ago
Downloads
4
README

#MoonPixelAnimKit

MoonPixelAnimKit 是一个 MoonBit 原生像素动画资产解析、校验与运行时工具链，面向 2D 游戏、Canvas/WebAssembly 可视化、教学示例和自动化资源流水线。

项目 v1 支持 Aseprite 导出的 sprite sheet JSON，并提供 .ase/.aseprite 文件基础结构解析、动画 clip 构建、帧级 hitbox/hurtbox/collision box 提取、资源校验、Phaser/Canvas 适配数据导出和 CLI smoke 示例。

#项目状态

  • MoonBit 主体实现：JSON 解析、二进制结构解析、校验、runtime、导出、报告和测试。
  • 当前版本：0.1.1。
  • Mooncakes 包名：WangYF0829/moonpixelanimkit。
  • 许可证：MIT。
  • 参考说明：本项目不移植 Aseprite 源码，不打包 Aseprite 程序，只依据公开文件格式说明、导出 JSON 结构和自制 fixture 实现兼容解析。

#安装

Mooncakes 安装命令：

moon add WangYF0829/moonpixelanimkit

本地开发：

moon check
moon test
moon run examples/basic
moon run cmd/main
moon run cmd/main -- --json
moon run cmd/main -- --ase

#最小示例

let parsed = @moonpixelanimkit.parse_sprite_sheet_json(json_text)
if parsed.ok {
  let library = @moonpixelanimkit.build_animation_library(parsed.sheet)
  let player = @moonpixelanimkit.AnimationPlayer::new(library, clip_name="idle")
  let next = player.step(120)
  println(next.current_frame().unwrap().name)
}

#核心功能

功能API
解析 Aseprite sprite sheet JSONparse_sprite_sheet_json(input)
校验资源结构validate_sprite_sheet(sheet) / validate_sprite_sheet_json(input)
解析 .ase/.aseprite 基础结构parse_aseprite_binary(bytes)
构建动画库build_animation_library(sheet)
动画播放推进AnimationPlayer::step(delta_ms)
提取 hitbox/hurtbox/collision boxbuild_frame_box_table(sheet)
导出 runtime manifestexport_runtime_manifest(sheet)
导出 Phaser 动画计划export_phaser_animation_plan(sheet)
导出 Canvas draw planbuild_canvas_draw_plan(sheet)
统计 atlas 与动画时长analyze_sprite_sheet(sheet)
构建帧时间轴build_sheet_timeline(sheet) / build_tag_timeline(sheet, tag)
检查游戏素材策略check_asset_policy(sheet, policy)
检查导出目标兼容性check_export_compatibility(sheet) / validate_sprite_sheet_json_for_export(input)
检查帧命名序列group_frame_names(sheet) / inspect_frame_name_groups(sheet)
CLI 报告moon run cmd/main

#支持范围

已支持：

  • Aseprite JSON frames 数组形式和对象形式。
  • frame、duration、rotated、trimmed、spriteSourceSize、sourceSize。
  • meta.image、meta.size、meta.frameTags、meta.layers、meta.slices。
  • .ase/.aseprite header、frame header、layer chunk、cel chunk、tags chunk、palette chunk、slice chunk 的元数据解析。
  • forward、reverse、pingpong 动画方向映射。
  • 动画 clip、player、frame sampling。
  • 资源错误与警告报告，包括重复帧名、非法矩形、非法 tag 范围、缺失 box slice 等。
  • atlas 利用率、duration bucket、帧时间轴和素材策略检查。
  • Phaser、Canvas 和 runtime manifest 导出前兼容性预检。
  • hero_run_0 这类帧命名序列分组、编号缺口检查和命名报告。

暂不支持：

  • 不做 Aseprite 编辑器，不做播放器。
  • v1 不解压 zlib compressed cel 像素，只识别并报告压缩 cel。
  • 不做图像滤镜、像素 diff、纹理打包算法。
  • 不替代 Phaser、Canvas、Godot、Unity 的渲染系统。

#工程验收

moon check
moon build
moon test
moon run cmd/main
moon run cmd/main -- --json
moon run cmd/main -- --ase
moon run examples/basic
moon publish --dry-run

CI 已覆盖检查、构建、测试、CLI text/json/ase smoke 和 basic example。

#开源合规

本项目采用 MIT 许可证。测试数据均为代码内自制 fixture，不包含第三方图片、音频、字体或 Aseprite 官方二进制文件。Aseprite 是第三方软件，本项目仅实现对其公开导出格式和公开文件结构的兼容读取。

#
AnimationClip

source
pub(all) struct AnimationClip {
  name : String
  direction : TagDirection
  loop_mode : LoopMode
  frames : Array[AnimationFrameRef]
  total_duration_ms : Int
} derive(Eq, 
Debug)

#
AnimationClip::frame_at

source
fn AnimationClip::frame_at(self : AnimationClip, index : Int) -> AnimationFrameRef?

#
AnimationClip::frame_count

source
fn AnimationClip::frame_count(self : AnimationClip) -> Int

#
AnimationClip::is_valid

source
fn AnimationClip::is_valid(self : AnimationClip) -> Bool

#
AnimationClip::new

source
fn AnimationClip::new(name : String, frames : Array[AnimationFrameRef], direction? : TagDirection, loop_mode? : LoopMode) -> AnimationClip

#
AnimationFrameRef

source
pub(all) struct AnimationFrameRef {
  name : String
  frame_index : Int
  duration_ms : Int
  rect : Rect
} derive(Eq, 
Debug)

#
AnimationFrameRef::from_frame

source
fn AnimationFrameRef::from_frame(frame : FrameInfo) -> AnimationFrameRef

#
AnimationLibrary

source
pub(all) struct AnimationLibrary {
  texture_image : String
  atlas_size : Size
  clips : Array[AnimationClip]
} derive(Eq, 
Debug)

#
AnimationLibrary::empty

source

#
AnimationLibrary::find_clip

source
fn AnimationLibrary::find_clip(self : AnimationLibrary, name : String) -> AnimationClip?

#
AnimationPlayer

source
pub(all) struct AnimationPlayer {
  library : AnimationLibrary
  clip_name : String
  frame_cursor : Int
  elapsed_in_frame_ms : Int
  playing : Bool
  completed : Bool
  forward : Bool
} derive(Eq, 
Debug)

#
AnimationPlayer::current_clip

source
fn AnimationPlayer::current_clip(self : AnimationPlayer) -> AnimationClip?

#
AnimationPlayer::current_frame

source
fn AnimationPlayer::current_frame(self : AnimationPlayer) -> AnimationFrameRef?

#
AnimationPlayer::new

source
fn AnimationPlayer::new(library : AnimationLibrary, clip_name? : String) -> AnimationPlayer

#
AnimationPlayer::pause

source

#
AnimationPlayer::play

source

#
AnimationPlayer::reset

source

#
AnimationPlayer::set_clip

source
fn AnimationPlayer::set_clip(self : AnimationPlayer, clip_name : String) -> AnimationPlayer

#
AnimationPlayer::step

source
fn AnimationPlayer::step(self : AnimationPlayer, delta_ms : Int) -> AnimationPlayer

#
AseChunk

source
pub(all) struct AseChunk {
  frame_index : Int
  offset : Int
  size : Int
  kind : Int
  kind_name : String
  name : String
  layer_index : Int
  cel_type : Int
  opacity : Int
  child_level : Int
  extra : String
} derive(Eq, 
Debug)

#
AseChunk::end_offset

source
fn AseChunk::end_offset(self : AseChunk) -> Int

#
AseChunk::new

source
fn AseChunk::new(frame_index : Int, offset : Int, size : Int, kind : Int, kind_name : String, name? : String, layer_index? : Int, cel_type? : Int, opacity? : Int, child_level? : Int, extra? : String) -> AseChunk

#
AseFile

source
pub(all) struct AseFile {
  header : AseHeader
  frames : Array[AseFrame]
  source_length : Int
} derive(Eq, 
Debug)

#
AseFile::chunk_count

source
fn AseFile::chunk_count(self : AseFile) -> Int

#
AseFile::empty

source
fn AseFile::empty() -> AseFile

#
AseFrame

source
pub(all) struct AseFrame {
  index : Int
  offset : Int
  size : Int
  duration_ms : Int
  chunk_count : Int
  chunks : Array[AseChunk]
} derive(Eq, 
Debug)

#
AseFrame::new

source
fn AseFrame::new(index : Int, offset : Int, size : Int, duration_ms : Int, chunk_count : Int, chunks : Array[AseChunk]) -> AseFrame

#
AseHeader

source
pub(all) struct AseHeader {
  file_size : Int
  frame_count : Int
  width : Int
  height : Int
  color_depth : Int
  flags : Int
  speed_ms : Int
  transparent_index : Int
  color_count : Int
  pixel_width : Int
  pixel_height : Int
} derive(Eq, 
Debug)

#
AseHeader::canvas_size

source
fn AseHeader::canvas_size(self : AseHeader) -> Size

#
AseHeader::empty

source
fn AseHeader::empty() -> AseHeader

#
AseParseResult

source
pub(all) struct AseParseResult {
  ok : Bool
  file : AseFile
  error : PixelAnimError
} derive(Eq, 
Debug)

#
AseParseResult::failure

source

#
AseParseResult::success

source
fn AseParseResult::success(file : AseFile) -> AseParseResult

#
AssetPolicy

source
pub(all) struct AssetPolicy {
  min_frames : Int
  max_frames : Int
  require_tags : Bool
  require_box_slices : Bool
  allow_rotated_frames : Bool
  max_frame_duration_ms : Int
  max_atlas_waste_milli : Int
} derive(Eq, 
Debug)

#
AssetPolicy::game_sprite_default

source
fn AssetPolicy::game_sprite_default() -> AssetPolicy

#
AssetPolicy::relaxed

source
fn AssetPolicy::relaxed() -> AssetPolicy

#
AssetReport

source
pub(all) struct AssetReport {
  parse_ok : Bool
  validation_ok : Bool
  frame_count : Int
  tag_count : Int
  slice_count : Int
  layer_count : Int
  duration_ms : Int
  fps : Int
  manifest_bytes : Int
  message : String
} derive(Eq, 
Debug)

#
AssetReport::empty

source
fn AssetReport::empty() -> AssetReport

#
BoxKind

source
pub(all) enum BoxKind {
  BoxHit
  BoxHurt
  BoxCollision
  BoxOrigin
  BoxCustom(String)
} derive(Eq, 
Debug)

#
BoxKind::from_slice_name

source
fn BoxKind::from_slice_name(name : String) -> BoxKind

#
BoxKind::to_string

source
fn BoxKind::to_string(self : BoxKind) -> String

#
ByteReader

source
pub(all) struct ByteReader {
  bytes : Array[Int]
  offset : Int
} derive(Eq, 
Debug)

Non-owning reader over byte arrays. Values outside 0..255 are masked so generated fixtures and host-provided byte arrays behave consistently.

#
ByteReader::ascii_fixed_at

source
fn ByteReader::ascii_fixed_at(self : ByteReader, offset : Int, size : Int) -> String

#
ByteReader::ascii_z_at

source
fn ByteReader::ascii_z_at(self : ByteReader, offset : Int, limit : Int) -> String

#
ByteReader::at

source
fn ByteReader::at(bytes : Array[Int], offset : Int) -> ByteReader

#
ByteReader::byte_at

source
fn ByteReader::byte_at(self : ByteReader, offset : Int) -> Int

#
ByteReader::can_read

source
fn ByteReader::can_read(self : ByteReader, count : Int) -> Bool

#
ByteReader::fourcc_at

source
fn ByteReader::fourcc_at(self : ByteReader, offset : Int) -> String

#
ByteReader::length

source
fn ByteReader::length(self : ByteReader) -> Int

#
ByteReader::matches_u16

source
fn ByteReader::matches_u16(self : ByteReader, offset : Int, value : Int) -> Bool

#
ByteReader::new

source
fn ByteReader::new(bytes : Array[Int]) -> ByteReader

#
ByteReader::remaining

source
fn ByteReader::remaining(self : ByteReader) -> Int

#
ByteReader::slice

source
fn ByteReader::slice(self : ByteReader, offset : Int, size : Int) -> Array[Int]

#
ByteReader::slice_can_read

source
fn ByteReader::slice_can_read(self : ByteReader, offset : Int, count : Int) -> Bool

#
ByteReader::u16_le_at

source
fn ByteReader::u16_le_at(self : ByteReader, offset : Int) -> Int

#
ByteReader::u32_le_at

source
fn ByteReader::u32_le_at(self : ByteReader, offset : Int) -> Int

#
CanvasDrawCommand

source
pub(all) struct CanvasDrawCommand {
  frame_name : String
  source : Rect
  destination : Rect
  duration_ms : Int
} derive(Eq, 
Debug)

#
CanvasDrawCommand::new

source
fn CanvasDrawCommand::new(frame_name : String, source : Rect, destination : Rect, duration_ms : Int) -> CanvasDrawCommand

#
DurationBucket

source
pub(all) struct DurationBucket {
  name : String
  min_ms : Int
  max_ms : Int
  count : Int
} derive(Eq, 
Debug)

#
DurationBucket::new

source
fn DurationBucket::new(name : String, min_ms : Int, max_ms : Int, count? : Int) -> DurationBucket

#
ExportCompatibilityOptions

source
pub(all) struct ExportCompatibilityOptions {
  target : RuntimeTarget
  require_frame_tags : Bool
  require_layer_metadata : Bool
  require_slice_boxes : Bool
  require_hitbox : Bool
  require_hurtbox : Bool
  require_collision_box : Bool
  require_image_name : Bool
  allow_rotated_frames : Bool
  allow_trimmed_frames : Bool
  max_atlas_width : Int
  max_atlas_height : Int
  min_frame_duration_ms : Int
  max_frame_duration_ms : Int
} derive(Eq, 
Debug)

#
ExportCompatibilityOptions::canvas2d

source

#
ExportCompatibilityOptions::phaser3

source

#
ExportCompatibilityOptions::runtime_manifest

source

#
ExportCompatibilityOptions::strict_game_asset

source

#
FrameBox

source
pub(all) struct FrameBox {
  frame_index : Int
  frame_name : String
  name : String
  kind : BoxKind
  bounds : Rect
  pivot : Point
  has_pivot : Bool
} derive(Eq, 
Debug)

#
FrameBox::new

source
fn FrameBox::new(frame_index : Int, frame_name : String, name : String, kind : BoxKind, bounds : Rect, pivot? : Point, has_pivot? : Bool) -> FrameBox

#
FrameBoxTable

source
pub(all) struct FrameBoxTable {
  boxes : Array[FrameBox]
} derive(Eq, 
Debug)

#
FrameBoxTable::count_kind

source
fn FrameBoxTable::count_kind(self : FrameBoxTable, kind : BoxKind) -> Int

#
FrameBoxTable::empty

source

#
FrameBoxTable::find_named

source
fn FrameBoxTable::find_named(self : FrameBoxTable, frame_index : Int, name : String) -> FrameBox?

#
FrameBoxTable::for_frame

source
fn FrameBoxTable::for_frame(self : FrameBoxTable, frame_index : Int) -> Array[FrameBox]

#
FrameInfo

source
pub(all) struct FrameInfo {
  name : String
  index : Int
  rect : Rect
  rotated : Bool
  trimmed : Bool
  sprite_source_size : Rect
  source_size : Size
  duration_ms : Int
} derive(Eq, 
Debug)

#
FrameInfo::duration_seconds

source
fn FrameInfo::duration_seconds(self : FrameInfo) -> Double

#
FrameInfo::is_valid

source
fn FrameInfo::is_valid(self : FrameInfo) -> Bool

#
FrameInfo::new

source
fn FrameInfo::new(name : String, index : Int, rect : Rect, duration_ms : Int, rotated? : Bool, trimmed? : Bool, sprite_source_size? : Rect, source_size? : Size) -> FrameInfo

#
FrameNameGroup

source
pub(all) struct FrameNameGroup {
  stem : String
  count : Int
  first_frame_index : Int
  last_frame_index : Int
  numeric_count : Int
  min_number : Int
  max_number : Int
} derive(Eq, 
Debug)

#
FrameNameGroup::has_number_gap

source
fn FrameNameGroup::has_number_gap(self : FrameNameGroup) -> Bool

#
FrameNameGroup::is_numbered

source
fn FrameNameGroup::is_numbered(self : FrameNameGroup) -> Bool

#
FrameNameGroup::new

source
fn FrameNameGroup::new(stem : String, frame : FrameInfo) -> FrameNameGroup

#
FrameNameParts

source
pub(all) struct FrameNameParts {
  original : String
  stem : String
  suffix_number : Int
  has_number : Bool
} derive(Eq, 
Debug)

#
FrameNameParts::new

source
fn FrameNameParts::new(original : String, stem : String, suffix_number? : Int, has_number? : Bool) -> FrameNameParts

#
FrameTag

source
pub(all) struct FrameTag {
  name : String
  from_index : Int
  to_index : Int
  direction : TagDirection
  color : String
  user_data : String
} derive(Eq, 
Debug)

#
FrameTag::contains_index

source
fn FrameTag::contains_index(self : FrameTag, index : Int) -> Bool

#
FrameTag::frame_count

source
fn FrameTag::frame_count(self : FrameTag) -> Int

#
FrameTag::new

source
fn FrameTag::new(name : String, from_index : Int, to_index : Int, direction? : TagDirection, color? : String, user_data? : String) -> FrameTag

#
FrameTimelineEntry

source
pub(all) struct FrameTimelineEntry {
  frame_index : Int
  frame_name : String
  start_ms : Int
  end_ms : Int
  duration_ms : Int
} derive(Eq, 
Debug)

#
FrameTimelineEntry::contains

source
fn FrameTimelineEntry::contains(self : FrameTimelineEntry, ms : Int) -> Bool

#
FrameTimelineEntry::new

source
fn FrameTimelineEntry::new(frame_index : Int, frame_name : String, start_ms : Int, duration_ms : Int) -> FrameTimelineEntry

#
IssueSeverity

source
pub(all) enum IssueSeverity {
  IssueError
  IssueWarning
} derive(Eq, 
Debug)

#
IssueSeverity::to_string

source
fn IssueSeverity::to_string(self : IssueSeverity) -> String

#
LayerInfo

source
pub(all) struct LayerInfo {
  name : String
  opacity : Int
  blend_mode : String
  visible : Bool
} derive(Eq, 
Debug)

#
LayerInfo::is_visible

source
fn LayerInfo::is_visible(self : LayerInfo) -> Bool

#
LayerInfo::new

source
fn LayerInfo::new(name : String, opacity? : Int, blend_mode? : String, visible? : Bool) -> LayerInfo

#
LoopMode

source
pub(all) enum LoopMode {
  LoopOnce
  LoopRepeat
  LoopPingPong
} derive(Eq, 
Debug)

#
LoopMode::to_string

source
fn LoopMode::to_string(self : LoopMode) -> String

#
NamingIssue

source
pub(all) struct NamingIssue {
  stem : String
  code : String
  message : String
} derive(Eq, 
Debug)

#
NamingIssue::new

source
fn NamingIssue::new(stem : String, code : String, message : String) -> NamingIssue

#
PixelAnimError

source
pub(all) struct PixelAnimError {
  kind : PixelAnimErrorKind
  path : String
  offset : Int
  message : String
} derive(Eq, 
Debug)

#
PixelAnimError::code

source
fn PixelAnimError::code(self : PixelAnimError) -> String

#
PixelAnimError::is_error

source
fn PixelAnimError::is_error(self : PixelAnimError) -> Bool

#
PixelAnimError::new

source
fn PixelAnimError::new(kind : PixelAnimErrorKind, message : String, path? : String, offset? : Int) -> PixelAnimError

#
PixelAnimError::none

source

#
PixelAnimErrorKind

source
pub(all) enum PixelAnimErrorKind {
  ErrorNone
  ErrorJsonParse
  ErrorExpectedObject
  ErrorMissingField
  ErrorInvalidField
  ErrorInvalidFrame
  ErrorInvalidTag
  ErrorInvalidSlice
  ErrorInvalidLayer
  ErrorNotAseprite
  ErrorUnsupportedChunk
  ErrorChunkOutOfBounds
  ErrorTruncatedData
  ErrorUnsupportedCompression
  ErrorRuntimeState
  ErrorInvalidArgument
} derive(Eq, 
Debug)

Error categories used by the JSON parser, binary parser, validator, runtime builder, exporter, and CLI report model.

#
PixelAnimErrorKind::code

source
fn PixelAnimErrorKind::code(self : PixelAnimErrorKind) -> String

#
PixelAnimParseResult

source
pub(all) struct PixelAnimParseResult {
  ok : Bool
  sheet : SpriteSheet
  error : PixelAnimError
} derive(Eq, 
Debug)

#
PixelAnimParseResult::failure

source

#
PixelAnimParseResult::success

source

#
Point

source
pub(all) struct Point {
  x : Int
  y : Int
} derive(Eq, 
Debug)

#
Point::new

source
fn Point::new(x : Int, y : Int) -> Point

#
Rect

source
pub(all) struct Rect {
  x : Int
  y : Int
  width : Int
  height : Int
} derive(Eq, 
Debug)

#
Rect::area

source
fn Rect::area(self : Rect) -> Int

#
Rect::bottom

source
fn Rect::bottom(self : Rect) -> Int

#
Rect::contains_point

source
fn Rect::contains_point(self : Rect, point : Point) -> Bool

#
Rect::contains_rect

source
fn Rect::contains_rect(self : Rect, other : Rect) -> Bool

#
Rect::empty

source
fn Rect::empty() -> Rect

#
Rect::intersects

source
fn Rect::intersects(self : Rect, other : Rect) -> Bool

#
Rect::is_positive

source
fn Rect::is_positive(self : Rect) -> Bool

#
Rect::new

source
fn Rect::new(x : Int, y : Int, width : Int, height : Int) -> Rect

#
Rect::right

source
fn Rect::right(self : Rect) -> Int

#
ReportFormat

source
pub(all) enum ReportFormat {
  ReportText
  ReportJson
} derive(Eq, 
Debug)

#
RuntimeTarget

source
pub(all) enum RuntimeTarget {
  TargetRuntimeManifest
  TargetCanvas2D
  TargetPhaser3
  TargetGenericEngine
} derive(Eq, 
Debug)

Runtime/export targets that commonly consume Aseprite animation metadata.

#
RuntimeTarget::expects_external_renderer

source
fn RuntimeTarget::expects_external_renderer(self : RuntimeTarget) -> Bool

#
RuntimeTarget::requires_box_metadata_by_default

source
fn RuntimeTarget::requires_box_metadata_by_default(self : RuntimeTarget) -> Bool

#
RuntimeTarget::to_string

source
fn RuntimeTarget::to_string(self : RuntimeTarget) -> String

#
Size

source
pub(all) struct Size {
  width : Int
  height : Int
} derive(Eq, 
Debug)

#
Size::area

source
fn Size::area(self : Size) -> Int

#
Size::empty

source
fn Size::empty() -> Size

#
Size::is_positive

source
fn Size::is_positive(self : Size) -> Bool

#
Size::new

source
fn Size::new(width : Int, height : Int) -> Size

#
SliceInfo

source
pub(all) struct SliceInfo {
  name : String
  color : String
  keys : Array[SliceKey]
} derive(Eq, 
Debug)

#
SliceInfo::has_keys

source
fn SliceInfo::has_keys(self : SliceInfo) -> Bool

#
SliceInfo::key_for_frame

source
fn SliceInfo::key_for_frame(self : SliceInfo, frame_index : Int) -> SliceKey?

#
SliceInfo::new

source
fn SliceInfo::new(name : String, keys : Array[SliceKey], color? : String) -> SliceInfo

#
SliceKey

source
pub(all) struct SliceKey {
  frame : Int
  bounds : Rect
  center : Rect
  pivot : Point
  has_center : Bool
  has_pivot : Bool
} derive(Eq, 
Debug)

#
SliceKey::is_valid

source
fn SliceKey::is_valid(self : SliceKey) -> Bool

#
SliceKey::new

source
fn SliceKey::new(frame : Int, bounds : Rect, center? : Rect, pivot? : Point, has_center? : Bool, has_pivot? : Bool) -> SliceKey

#
SpriteSheet

source
pub(all) struct SpriteSheet {
  frames : Array[FrameInfo]
  meta : SpriteSheetMeta
  source_length : Int
} derive(Eq, 
Debug)

#
SpriteSheet::duration_ms

source
fn SpriteSheet::duration_ms(self : SpriteSheet) -> Int

#
SpriteSheet::duration_seconds

source
fn SpriteSheet::duration_seconds(self : SpriteSheet) -> Double

#
SpriteSheet::empty

source
fn SpriteSheet::empty() -> SpriteSheet

#
SpriteSheet::find_frame

source
fn SpriteSheet::find_frame(self : SpriteSheet, name : String) -> FrameInfo?

#
SpriteSheet::find_tag

source
fn SpriteSheet::find_tag(self : SpriteSheet, name : String) -> FrameTag?

#
SpriteSheet::frame_at

source
fn SpriteSheet::frame_at(self : SpriteSheet, index : Int) -> FrameInfo?

#
SpriteSheet::frame_count

source
fn SpriteSheet::frame_count(self : SpriteSheet) -> Int

#
SpriteSheetMeta

source
pub(all) struct SpriteSheetMeta {
  app : String
  version : String
  image : String
  format : String
  scale : String
  size : Size
  frame_tags : Array[FrameTag]
  layers : Array[LayerInfo]
  slices : Array[SliceInfo]
} derive(Eq, 
Debug)

#
SpriteSheetMeta::empty

source

#
SpriteSheetStats

source
pub(all) struct SpriteSheetStats {
  frame_count : Int
  tag_count : Int
  slice_count : Int
  layer_count : Int
  atlas_area : Int
  used_area : Int
  utilization_milli : Int
  trimmed_frames : Int
  rotated_frames : Int
  total_duration_ms : Int
  shortest_duration_ms : Int
  longest_duration_ms : Int
  average_duration_ms : Int
} derive(Eq, 
Debug)

#
SpriteSheetStats::empty

source

#
SpriteSheetStats::utilization_percent

source
fn SpriteSheetStats::utilization_percent(self : SpriteSheetStats) -> Double

#
TagDirection

source
pub(all) enum TagDirection {
  DirectionForward
  DirectionReverse
  DirectionPingPong
  DirectionPingPongReverse
  DirectionUnknown(String)
} derive(Eq, 
Debug)

#
TagDirection::from_string

source
fn TagDirection::from_string(value : String) -> TagDirection

#
TagDirection::is_pingpong

source
fn TagDirection::is_pingpong(self : TagDirection) -> Bool

#
TagDirection::to_string

source
fn TagDirection::to_string(self : TagDirection) -> String

#
ValidationIssue

source
pub(all) struct ValidationIssue {
  severity : IssueSeverity
  path : String
  code : String
  message : String
} derive(Eq, 
Debug)

#
ValidationIssue::error

source
fn ValidationIssue::error(message : String, path? : String, code? : String) -> ValidationIssue

#
ValidationIssue::warning

source
fn ValidationIssue::warning(message : String, path? : String, code? : String) -> ValidationIssue

#
ValidationReport

source
pub(all) struct ValidationReport {
  ok : Bool
  issues : Array[ValidationIssue]
  error_count : Int
  warning_count : Int
} derive(Eq, 
Debug)

#
ValidationReport::empty

source

#
ValidationReport::new

source

#
ValidationReport::summary

source
fn ValidationReport::summary(self : ValidationReport) -> String

#
analytics_summary_text

source
fn analytics_summary_text(sheet : SpriteSheet) -> String

#
analyze_sprite_sheet

source
fn analyze_sprite_sheet(sheet : SpriteSheet) -> SpriteSheetStats

#
analyze_sprite_sheet_json

source
fn analyze_sprite_sheet_json(input : String) -> AssetReport

#
ase_binary_report

source
fn ase_binary_report(bytes : Array[Int], format? : ReportFormat) -> String

#
ase_file_supports_runtime_manifest

source
fn ase_file_supports_runtime_manifest(file : AseFile) -> Bool

#
ase_has_compressed_cels

source
fn ase_has_compressed_cels(file : AseFile) -> Bool

#
asset_report_from_json

source
fn asset_report_from_json(input : String, format? : ReportFormat) -> String

#
boxes_intersect

source
fn boxes_intersect(a : FrameBox, b : FrameBox) -> Bool

#
build_animation_library

source
fn build_animation_library(sheet : SpriteSheet) -> AnimationLibrary

#
build_canvas_draw_plan

source
fn build_canvas_draw_plan(sheet : SpriteSheet, scale? : Int) -> Array[CanvasDrawCommand]

#
build_duration_buckets

source
fn build_duration_buckets(sheet : SpriteSheet) -> Array[DurationBucket]

#
build_frame_box_table

source
fn build_frame_box_table(sheet : SpriteSheet) -> FrameBoxTable

#
build_sheet_timeline

source
fn build_sheet_timeline(sheet : SpriteSheet) -> Array[FrameTimelineEntry]

#
build_tag_timeline

source
fn build_tag_timeline(sheet : SpriteSheet, tag_name : String) -> Array[FrameTimelineEntry]

#
canvas_command_to_text

source
fn canvas_command_to_text(command : CanvasDrawCommand) -> String

#
check_asset_policy

source
fn check_asset_policy(sheet : SpriteSheet, policy : AssetPolicy) -> ValidationReport

#
check_export_compatibility

source
fn check_export_compatibility(sheet : SpriteSheet, options? : ExportCompatibilityOptions) -> ValidationReport

#
clip_to_json

source
fn clip_to_json(clip : AnimationClip) -> String

#
collect_ase_chunk_names

source
fn collect_ase_chunk_names(file : AseFile) -> Array[String]

#
collect_frame_names

source
fn collect_frame_names(sheet : SpriteSheet) -> Array[String]

#
collect_slice_names

source
fn collect_slice_names(sheet : SpriteSheet) -> Array[String]

#
collect_tag_names

source
fn collect_tag_names(sheet : SpriteSheet) -> Array[String]

#
estimate_clip_fps

source
fn estimate_clip_fps(clip : AnimationClip) -> Int

#
export_canvas_draw_plan_text

source
fn export_canvas_draw_plan_text(sheet : SpriteSheet, scale? : Int) -> String

#
export_phaser_animation_plan

source
fn export_phaser_animation_plan(sheet : SpriteSheet) -> String

#
export_runtime_manifest

source
fn export_runtime_manifest(sheet : SpriteSheet) -> String

#
export_runtime_manifest_from_parts

source
fn export_runtime_manifest_from_parts(sheet : SpriteSheet, library : AnimationLibrary, boxes : FrameBoxTable) -> String

#
first_intersection

source
fn first_intersection(boxes : Array[FrameBox], kind_a : BoxKind, kind_b : BoxKind) -> (FrameBox, FrameBox)?

#
fixture_aseprite_binary

source
fn fixture_aseprite_binary() -> Array[Int]

#
fixture_aseprite_json

source
fn fixture_aseprite_json() -> String

#
fixture_catalog_passed

source
fn fixture_catalog_passed() -> Bool

#
fixture_invalid_sprite_json

source
fn fixture_invalid_sprite_json() -> String

#
fixture_malformed_json

source
fn fixture_malformed_json() -> String

#
fixture_not_aseprite_binary

source
fn fixture_not_aseprite_binary() -> Array[Int]

#
fixture_not_object_json

source
fn fixture_not_object_json() -> String

#
fixture_object_frames_json

source
fn fixture_object_frames_json() -> String

#
fixture_truncated_aseprite_binary

source
fn fixture_truncated_aseprite_binary() -> Array[Int]

#
frame_box_to_json

source
fn frame_box_to_json(box : FrameBox) -> String

#
frame_ref_to_json

source
fn frame_ref_to_json(frame : AnimationFrameRef) -> String

#
group_frame_names

source
fn group_frame_names(sheet : SpriteSheet) -> Array[FrameNameGroup]

#
has_required_box_kinds

source
fn has_required_box_kinds(table : FrameBoxTable, require_hit? : Bool, require_hurt? : Bool, require_collision? : Bool) -> Bool

#
infer_frame_rate

source
fn infer_frame_rate(sheet : SpriteSheet) -> Int

#
inspect_fixture_report

source
fn inspect_fixture_report(format? : ReportFormat) -> String

#
inspect_frame_name_groups

source
fn inspect_frame_name_groups(sheet : SpriteSheet) -> Array[NamingIssue]

#
library_smoke_passed

source
fn library_smoke_passed() -> Bool

#
merge_validation_reports

source
fn merge_validation_reports(first : ValidationReport, second : ValidationReport) -> ValidationReport

#
naming_report_text

source
fn naming_report_text(sheet : SpriteSheet) -> String

#
parse_aseprite_binary

source
fn parse_aseprite_binary(bytes : Array[Int]) -> AseParseResult

Parse an .ase or .aseprite byte array and return structural metadata. Pixel decompression is intentionally not exposed in v1.

#
parse_aseprite_file

source
fn parse_aseprite_file(bytes : Array[Int]) -> AseParseResult

#
parse_sprite_sheet_json

source
fn parse_sprite_sheet_json(input : String) -> PixelAnimParseResult

Parse Aseprite sprite sheet JSON exported with --format json-array or the default object form. This is the primary high-level entry point.

#
parse_sprite_sheet_value

source
fn parse_sprite_sheet_value(json : Json, source_length? : Int) -> PixelAnimParseResult

fn recommended_aseprite_export_flags(options? : ExportCompatibilityOptions) -> String

#
rect_to_json

source
fn rect_to_json(rect : Rect) -> String

#
sample_clip_at

source
fn sample_clip_at(clip : AnimationClip, elapsed_ms : Int) -> AnimationFrameRef?

#
sheet_has_rotated_frames

source
fn sheet_has_rotated_frames(sheet : SpriteSheet) -> Bool

#
sheet_uses_trimmed_frames

source
fn sheet_uses_trimmed_frames(sheet : SpriteSheet) -> Bool

#
size_to_json

source
fn size_to_json(size : Size) -> String

#
split_frame_name

source
fn split_frame_name(name : String) -> FrameNameParts

#
timeline_frame_at

source
fn timeline_frame_at(entries : Array[FrameTimelineEntry], elapsed_ms : Int, looped? : Bool) -> FrameTimelineEntry?

#
timeline_total_duration

source
fn timeline_total_duration(entries : Array[FrameTimelineEntry]) -> Int

#
validate_ase_file

source
fn validate_ase_file(file : AseFile) -> ValidationReport

#
validate_sprite_sheet

source
fn validate_sprite_sheet(sheet : SpriteSheet) -> ValidationReport

#
validate_sprite_sheet_json

source
fn validate_sprite_sheet_json(input : String) -> ValidationReport

Validate without forcing callers to keep the parsed value.

#
validate_sprite_sheet_json_for_export

source
fn validate_sprite_sheet_json_for_export(input : String, options? : ExportCompatibilityOptions) -> ValidationReport

#
validation_report_has_code

source
fn validation_report_has_code(report : ValidationReport, code : String) -> Bool

Source Files

Powered by MoonBit

Site sourceReport issuePackagesBuild queueSkillsStatistics

© 2026 mooncakes.io