// Based off the LDtk 1.5.3 JSON Schema
use assets_manager::{loader::JsonLoader, Asset};
use serde::{Deserialize, Serialize};
use std::collections::HashMap;
// assets_manager definitions for these resources
impl Asset for Project {
    const EXTENSION: &'static str = "ldtk";
    type Loader = JsonLoader;
}
impl Asset for Level {
    const EXTENSION: &'static str = "ldtkl";
    type Loader = JsonLoader;
}
/// This file is a JSON schema of files created by LDtk level editor (https://ldtk.io).
///
/// This is the root of any Project JSON file. It contains:  - the project settings, - an
/// array of levels, - a group of definitions (that can probably be safely ignored for most
/// users).
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Project {
    /// This object is not actually used by LDtk. It ONLY exists to force explicit references to
    /// all types, to make sure QuickType finds them and integrate all of them. Otherwise,
    /// Quicktype will drop types that are not explicitely used.
    #[serde(rename = "__FORCED_REFS")]
    pub(crate) forced_refs: Option<ForcedRefs>,
    /// LDtk application build identifier.<br/>  This is only used to identify the LDtk version
    /// that generated this particular project file, which can be useful for specific bug fixing.
    /// Note that the build identifier is just the date of the release, so it's not unique to
    /// each user (one single global ID per LDtk public release), and as a result, completely
    /// anonymous.
    pub(crate) app_build_id: f64,
    /// Number of backup files to keep, if the `backupOnSave` is TRUE
    pub(crate) backup_limit: i64,
    /// If TRUE, an extra copy of the project will be created in a sub folder, when saving.
    pub(crate) backup_on_save: bool,
    /// Target relative path to store backup files
    pub(crate) backup_rel_path: Option<String>,
    /// Project background color
    pub(crate) bg_color: String,
    /// An array of command lines that can be ran manually by the user
    pub(crate) custom_commands: Vec<LdtkCustomCommand>,
    /// Default height for new entities
    pub(crate) default_entity_height: i64,
    /// Default width for new entities
    pub(crate) default_entity_width: i64,
    /// Default grid size for new layers
    pub(crate) default_grid_size: i64,
    /// Default background color of levels
    pub(crate) default_level_bg_color: String,
    /// **WARNING**: this field will move to the `worlds` array after the "multi-worlds" update.
    /// It will then be `null`. You can enable the Multi-worlds advanced project option to enable
    /// the change immediately.<br/><br/>  Default new level height
    pub(crate) default_level_height: Option<i64>,
    /// **WARNING**: this field will move to the `worlds` array after the "multi-worlds" update.
    /// It will then be `null`. You can enable the Multi-worlds advanced project option to enable
    /// the change immediately.<br/><br/>  Default new level width
    pub(crate) default_level_width: Option<i64>,
    /// Default X pivot (0 to 1) for new entities
    pub(crate) default_pivot_x: f64,
    /// Default Y pivot (0 to 1) for new entities
    pub(crate) default_pivot_y: f64,
    /// A structure containing all the definitions of this project
    pub(crate) defs: Definitions,
    /// If the project isn't in MultiWorlds mode, this is the IID of the internal "dummy" World.
    pub(crate) dummy_world_iid: String,
    /// If TRUE, the exported PNGs will include the level background (color or image).
    pub(crate) export_level_bg: bool,
    /// **WARNING**: this deprecated value is no longer exported since version 0.9.3  Replaced
    /// by: `imageExportMode`
    pub(crate) export_png: Option<bool>,
    /// If TRUE, a Tiled compatible file will also be generated along with the LDtk JSON file
    /// (default is FALSE)
    pub(crate) export_tiled: bool,
    /// If TRUE, one file will be saved for the project (incl. all its definitions) and one file
    /// in a sub-folder for each level.
    pub(crate) external_levels: bool,
    /// An array containing various advanced flags (ie. options or other states). Possible
    /// values: `DiscardPreCsvIntGrid`, `ExportOldTableOfContentData`,
    /// `ExportPreCsvIntGridFormat`, `IgnoreBackupSuggest`, `PrependIndexToLevelFileNames`,
    /// `MultiWorlds`, `UseMultilinesType`
    pub(crate) flags: Vec<Flag>,
    /// Naming convention for Identifiers (first-letter uppercase, full uppercase etc.) Possible
    /// values: `Capitalize`, `Uppercase`, `Lowercase`, `Free`
    pub(crate) identifier_style: IdentifierStyle,
    /// Unique project identifier
    pub(crate) iid: String,
    /// "Image export" option when saving project. Possible values: `None`, `OneImagePerLayer`,
    /// `OneImagePerLevel`, `LayersAndLevels`
    pub(crate) image_export_mode: ImageExportMode,
    /// File format version
    pub(crate) json_version: String,
    /// The default naming convention for level identifiers.
    pub(crate) level_name_pattern: String,
    /// All levels. The order of this array is only relevant in `LinearHorizontal` and
    /// `linearVertical` world layouts (see `worldLayout` value).<br/>  Otherwise, you should
    /// refer to the `worldX`,`worldY` coordinates of each Level.
    pub(crate) levels: Vec<Level>,
    /// If TRUE, the Json is partially minified (no indentation, nor line breaks, default is
    /// FALSE)
    pub(crate) minify_json: bool,
    /// Next Unique integer ID available
    pub(crate) next_uid: i64,
    /// File naming pattern for exported PNGs
    pub(crate) png_file_pattern: Option<String>,
    /// If TRUE, a very simplified will be generated on saving, for quicker & easier engine
    /// integration.
    pub(crate) simplified_export: bool,
    /// All instances of entities that have their `exportToToc` flag enabled are listed in this
    /// array.
    pub(crate) toc: Vec<LdtkTableOfContentEntry>,
    /// This optional description is used by LDtk Samples to show up some informations and
    /// instructions.
    pub(crate) tutorial_desc: Option<String>,
    /// **WARNING**: this field will move to the `worlds` array after the "multi-worlds" update.
    /// It will then be `null`. You can enable the Multi-worlds advanced project option to enable
    /// the change immediately.<br/><br/>  Height of the world grid in pixels.
    pub(crate) world_grid_height: Option<i64>,
    /// **WARNING**: this field will move to the `worlds` array after the "multi-worlds" update.
    /// It will then be `null`. You can enable the Multi-worlds advanced project option to enable
    /// the change immediately.<br/><br/>  Width of the world grid in pixels.
    pub(crate) world_grid_width: Option<i64>,
    /// **WARNING**: this field will move to the `worlds` array after the "multi-worlds" update.
    /// It will then be `null`. You can enable the Multi-worlds advanced project option to enable
    /// the change immediately.<br/><br/>  An enum that describes how levels are organized in
    /// this project (ie. linearly or in a 2D space). Possible values: &lt;`null`&gt;, `Free`,
    /// `GridVania`, `LinearHorizontal`, `LinearVertical`
    pub(crate) world_layout: Option<WorldLayout>,
    /// This array will be empty, unless you enable the Multi-Worlds in the project advanced
    /// settings.<br/><br/> - in current version, a LDtk project file can only contain a single
    /// world with multiple levels in it. In this case, levels and world layout related settings
    /// are stored in the root of the JSON.<br/> - with "Multi-worlds" enabled, there will be a
    /// `worlds` array in root, each world containing levels and layout settings. Basically, it's
    /// pretty much only about moving the `levels` array to the `worlds` array, along with world
    /// layout related values (eg. `worldGridWidth` etc).<br/><br/>If you want to start
    /// supporting this future update easily, please refer to this documentation:
    /// https://github.com/deepnight/ldtk/issues/231
    pub(crate) worlds: Vec<World>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct LdtkCustomCommand {
    pub(crate) command: String,
    /// Possible values: `Manual`, `AfterLoad`, `BeforeSave`, `AfterSave`
    pub(crate) when: When,
}
/// Possible values: `Manual`, `AfterLoad`, `BeforeSave`, `AfterSave`
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum When {
    #[serde(rename = "AfterLoad")]
    AfterLoad,
    #[serde(rename = "AfterSave")]
    AfterSave,
    #[serde(rename = "BeforeSave")]
    BeforeSave,
    Manual,
}
/// If you're writing your own LDtk importer, you should probably just ignore *most* stuff in
/// the `defs` section, as it contains data that are mostly important to the editor. To keep
/// you away from the `defs` section and avoid some unnecessary JSON parsing, important data
/// from definitions is often duplicated in fields prefixed with a double underscore (eg.
/// `__identifier` or `__type`).  The 2 only definition types you might need here are
/// **Tilesets** and **Enums**.
///
/// A structure containing all the definitions of this project
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Definitions {
    /// All entities definitions, including their custom fields
    pub(crate) entities: Vec<EntityDefinition>,
    /// All internal enums
    pub(crate) enums: Vec<EnumDefinition>,
    /// Note: external enums are exactly the same as `enums`, except they have a `relPath` to
    /// point to an external source file.
    pub(crate) external_enums: Vec<EnumDefinition>,
    /// All layer definitions
    pub(crate) layers: Vec<LayerDefinition>,
    /// All custom fields available to all levels.
    pub(crate) level_fields: Vec<FieldDefinition>,
    /// All tilesets
    pub(crate) tilesets: Vec<TilesetDefinition>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct EntityDefinition {
    /// If enabled, this entity is allowed to stay outside of the current level bounds
    pub(crate) allow_out_of_bounds: bool,
    /// Base entity color
    pub(crate) color: String,
    /// User defined documentation for this element to provide help/tips to level designers.
    pub(crate) doc: Option<String>,
    /// If enabled, all instances of this entity will be listed in the project "Table of content"
    /// object.
    pub(crate) export_to_toc: bool,
    /// Array of field definitions
    pub(crate) field_defs: Vec<FieldDefinition>,
    pub(crate) fill_opacity: f64,
    /// Pixel height
    pub(crate) height: i64,
    pub(crate) hollow: bool,
    /// User defined unique identifier
    pub(crate) identifier: String,
    /// Only applies to entities resizable on both X/Y. If TRUE, the entity instance width/height
    /// will keep the same aspect ratio as the definition.
    pub(crate) keep_aspect_ratio: bool,
    /// Possible values: `DiscardOldOnes`, `PreventAdding`, `MoveLastOne`
    pub(crate) limit_behavior: LimitBehavior,
    /// If TRUE, the maxCount is a "per world" limit, if FALSE, it's a "per level". Possible
    /// values: `PerLayer`, `PerLevel`, `PerWorld`
    pub(crate) limit_scope: LimitScope,
    pub(crate) line_opacity: f64,
    /// Max instances count
    pub(crate) max_count: i64,
    /// Max pixel height (only applies if the entity is resizable on Y)
    pub(crate) max_height: Option<i64>,
    /// Max pixel width (only applies if the entity is resizable on X)
    pub(crate) max_width: Option<i64>,
    /// Min pixel height (only applies if the entity is resizable on Y)
    pub(crate) min_height: Option<i64>,
    /// Min pixel width (only applies if the entity is resizable on X)
    pub(crate) min_width: Option<i64>,
    /// An array of 4 dimensions for the up/right/down/left borders (in this order) when using
    /// 9-slice mode for `tileRenderMode`.<br/>  If the tileRenderMode is not NineSlice, then
    /// this array is empty.<br/>  See: https://en.wikipedia.org/wiki/9-slice_scaling
    pub(crate) nine_slice_borders: Vec<i64>,
    /// Pivot X coordinate (from 0 to 1.0)
    pub(crate) pivot_x: f64,
    /// Pivot Y coordinate (from 0 to 1.0)
    pub(crate) pivot_y: f64,
    /// Possible values: `Rectangle`, `Ellipse`, `Tile`, `Cross`
    pub(crate) render_mode: RenderMode,
    /// If TRUE, the entity instances will be resizable horizontally
    pub(crate) resizable_x: bool,
    /// If TRUE, the entity instances will be resizable vertically
    pub(crate) resizable_y: bool,
    /// Display entity name in editor
    pub(crate) show_name: bool,
    /// An array of strings that classifies this entity
    pub(crate) tags: Vec<String>,
    /// **WARNING**: this deprecated value is no longer exported since version 1.2.0  Replaced
    /// by: `tileRect`
    pub(crate) tile_id: Option<i64>,
    pub(crate) tile_opacity: f64,
    /// An object representing a rectangle from an existing Tileset
    pub(crate) tile_rect: Option<TilesetRectangle>,
    /// An enum describing how the the Entity tile is rendered inside the Entity bounds. Possible
    /// values: `Cover`, `FitInside`, `Repeat`, `Stretch`, `FullSizeCropped`,
    /// `FullSizeUncropped`, `NineSlice`
    pub(crate) tile_render_mode: TileRenderMode,
    /// Tileset ID used for optional tile display
    pub(crate) tileset_id: Option<i64>,
    /// Unique Int identifier
    pub(crate) uid: i64,
    /// This tile overrides the one defined in `tileRect` in the UI
    pub(crate) ui_tile_rect: Option<TilesetRectangle>,
    /// Pixel width
    pub(crate) width: i64,
}
/// This section is mostly only intended for the LDtk editor app itself. You can safely
/// ignore it.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FieldDefinition {
    /// Human readable value type. Possible values: `Int, Float, String, Bool, Color,
    /// ExternEnum.XXX, LocalEnum.XXX, Point, FilePath`.<br/>  If the field is an array, this
    /// field will look like `Array<...>` (eg. `Array<Int>`, `Array<Point>` etc.)<br/>  NOTE: if
    /// you enable the advanced option **Use Multilines type**, you will have "*Multilines*"
    /// instead of "*String*" when relevant.
    #[serde(rename = "__type")]
    pub(crate) field_definition_type: String,
    /// Optional list of accepted file extensions for FilePath value type. Includes the dot:
    /// `.ext`
    pub(crate) accept_file_types: Option<Vec<String>>,
    /// Possible values: `Any`, `OnlySame`, `OnlyTags`, `OnlySpecificEntity`
    pub(crate) allowed_refs: AllowedRefs,
    pub(crate) allowed_refs_entity_uid: Option<i64>,
    pub(crate) allowed_ref_tags: Vec<String>,
    pub(crate) allow_out_of_level_ref: bool,
    /// Array max length
    pub(crate) array_max_length: Option<i64>,
    /// Array min length
    pub(crate) array_min_length: Option<i64>,
    pub(crate) auto_chain_ref: bool,
    /// TRUE if the value can be null. For arrays, TRUE means it can contain null values
    /// (exception: array of Points can't have null values).
    pub(crate) can_be_null: bool,
    /// Default value if selected value is null or invalid.
    pub(crate) default_override: Option<serde_json::Value>,
    /// User defined documentation for this field to provide help/tips to level designers about
    /// accepted values.
    pub(crate) doc: Option<String>,
    pub(crate) editor_always_show: bool,
    pub(crate) editor_cut_long_values: bool,
    pub(crate) editor_display_color: Option<String>,
    /// Possible values: `Hidden`, `ValueOnly`, `NameAndValue`, `EntityTile`, `LevelTile`,
    /// `Points`, `PointStar`, `PointPath`, `PointPathLoop`, `RadiusPx`, `RadiusGrid`,
    /// `ArrayCountWithLabel`, `ArrayCountNoLabel`, `RefLinkBetweenPivots`,
    /// `RefLinkBetweenCenters`
    pub(crate) editor_display_mode: EditorDisplayMode,
    /// Possible values: `Above`, `Center`, `Beneath`
    pub(crate) editor_display_pos: EditorDisplayPos,
    pub(crate) editor_display_scale: f64,
    /// Possible values: `ZigZag`, `StraightArrow`, `CurvedArrow`, `ArrowsLine`, `DashedLine`
    pub(crate) editor_link_style: EditorLinkStyle,
    pub(crate) editor_show_in_world: bool,
    pub(crate) editor_text_prefix: Option<String>,
    pub(crate) editor_text_suffix: Option<String>,
    /// If TRUE, the field value will be exported to the `toc` project JSON field. Only applies
    /// to Entity fields.
    pub(crate) export_to_toc: bool,
    /// User defined unique identifier
    pub(crate) identifier: String,
    /// TRUE if the value is an array of multiple values
    pub(crate) is_array: bool,
    /// Max limit for value, if applicable
    pub(crate) max: Option<f64>,
    /// Min limit for value, if applicable
    pub(crate) min: Option<f64>,
    /// Optional regular expression that needs to be matched to accept values. Expected format:
    /// `/some_reg_ex/g`, with optional "i" flag.
    pub(crate) regex: Option<String>,
    /// If enabled, this field will be searchable through LDtk command palette
    pub(crate) searchable: bool,
    pub(crate) symmetrical_ref: bool,
    /// Possible values: &lt;`null`&gt;, `LangPython`, `LangRuby`, `LangJS`, `LangLua`, `LangC`,
    /// `LangHaxe`, `LangMarkdown`, `LangJson`, `LangXml`, `LangLog`
    pub(crate) text_language_mode: Option<TextLanguageMode>,
    /// UID of the tileset used for a Tile
    pub(crate) tileset_uid: Option<i64>,
    /// Internal enum representing the possible field types. Possible values: F_Int, F_Float,
    /// F_String, F_Text, F_Bool, F_Color, F_Enum(...), F_Point, F_Path, F_EntityRef, F_Tile
    #[serde(rename = "type")]
    pub(crate) purple_type: String,
    /// Unique Int identifier
    pub(crate) uid: i64,
    /// If TRUE, the color associated with this field will override the Entity or Level default
    /// color in the editor UI. For Enum fields, this would be the color associated to their
    /// values.
    pub(crate) use_for_smart_color: bool,
}
/// Possible values: `Any`, `OnlySame`, `OnlyTags`, `OnlySpecificEntity`
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum AllowedRefs {
    Any,
    #[serde(rename = "OnlySame")]
    OnlySame,
    #[serde(rename = "OnlySpecificEntity")]
    OnlySpecificEntity,
    #[serde(rename = "OnlyTags")]
    OnlyTags,
}
/// Possible values: `Hidden`, `ValueOnly`, `NameAndValue`, `EntityTile`, `LevelTile`,
/// `Points`, `PointStar`, `PointPath`, `PointPathLoop`, `RadiusPx`, `RadiusGrid`,
/// `ArrayCountWithLabel`, `ArrayCountNoLabel`, `RefLinkBetweenPivots`,
/// `RefLinkBetweenCenters`
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum EditorDisplayMode {
    #[serde(rename = "ArrayCountNoLabel")]
    ArrayCountNoLabel,
    #[serde(rename = "ArrayCountWithLabel")]
    ArrayCountWithLabel,
    #[serde(rename = "EntityTile")]
    EntityTile,
    Hidden,
    #[serde(rename = "LevelTile")]
    LevelTile,
    #[serde(rename = "NameAndValue")]
    NameAndValue,
    #[serde(rename = "PointPath")]
    PointPath,
    #[serde(rename = "PointPathLoop")]
    PointPathLoop,
    #[serde(rename = "PointStar")]
    PointStar,
    Points,
    #[serde(rename = "RadiusGrid")]
    RadiusGrid,
    #[serde(rename = "RadiusPx")]
    RadiusPx,
    #[serde(rename = "RefLinkBetweenCenters")]
    RefLinkBetweenCenters,
    #[serde(rename = "RefLinkBetweenPivots")]
    RefLinkBetweenPivots,
    #[serde(rename = "ValueOnly")]
    ValueOnly,
}
/// Possible values: `Above`, `Center`, `Beneath`
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum EditorDisplayPos {
    Above,
    Beneath,
    Center,
}
/// Possible values: `ZigZag`, `StraightArrow`, `CurvedArrow`, `ArrowsLine`, `DashedLine`
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum EditorLinkStyle {
    #[serde(rename = "ArrowsLine")]
    ArrowsLine,
    #[serde(rename = "CurvedArrow")]
    CurvedArrow,
    #[serde(rename = "DashedLine")]
    DashedLine,
    #[serde(rename = "StraightArrow")]
    StraightArrow,
    #[serde(rename = "ZigZag")]
    ZigZag,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum TextLanguageMode {
    #[serde(rename = "LangC")]
    LangC,
    #[serde(rename = "LangHaxe")]
    LangHaxe,
    #[serde(rename = "LangJS")]
    LangJs,
    #[serde(rename = "LangJson")]
    LangJson,
    #[serde(rename = "LangLog")]
    LangLog,
    #[serde(rename = "LangLua")]
    LangLua,
    #[serde(rename = "LangMarkdown")]
    LangMarkdown,
    #[serde(rename = "LangPython")]
    LangPython,
    #[serde(rename = "LangRuby")]
    LangRuby,
    #[serde(rename = "LangXml")]
    LangXml,
}
/// Possible values: `DiscardOldOnes`, `PreventAdding`, `MoveLastOne`
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum LimitBehavior {
    #[serde(rename = "DiscardOldOnes")]
    DiscardOldOnes,
    #[serde(rename = "MoveLastOne")]
    MoveLastOne,
    #[serde(rename = "PreventAdding")]
    PreventAdding,
}
/// If TRUE, the maxCount is a "per world" limit, if FALSE, it's a "per level". Possible
/// values: `PerLayer`, `PerLevel`, `PerWorld`
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum LimitScope {
    #[serde(rename = "PerLayer")]
    PerLayer,
    #[serde(rename = "PerLevel")]
    PerLevel,
    #[serde(rename = "PerWorld")]
    PerWorld,
}
/// Possible values: `Rectangle`, `Ellipse`, `Tile`, `Cross`
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum RenderMode {
    Cross,
    Ellipse,
    Rectangle,
    Tile,
}
/// This object represents a custom sub rectangle in a Tileset image.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TilesetRectangle {
    /// Height in pixels
    pub(crate) h: i64,
    /// UID of the tileset
    pub(crate) tileset_uid: i64,
    /// Width in pixels
    pub(crate) w: i64,
    /// X pixels coordinate of the top-left corner in the Tileset image
    pub(crate) x: i64,
    /// Y pixels coordinate of the top-left corner in the Tileset image
    pub(crate) y: i64,
}
/// An enum describing how the the Entity tile is rendered inside the Entity bounds. Possible
/// values: `Cover`, `FitInside`, `Repeat`, `Stretch`, `FullSizeCropped`,
/// `FullSizeUncropped`, `NineSlice`
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum TileRenderMode {
    Cover,
    #[serde(rename = "FitInside")]
    FitInside,
    #[serde(rename = "FullSizeCropped")]
    FullSizeCropped,
    #[serde(rename = "FullSizeUncropped")]
    FullSizeUncropped,
    #[serde(rename = "NineSlice")]
    NineSlice,
    Repeat,
    Stretch,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct EnumDefinition {
    pub(crate) external_file_checksum: Option<String>,
    /// Relative path to the external file providing this Enum
    pub(crate) external_rel_path: Option<String>,
    /// Tileset UID if provided
    pub(crate) icon_tileset_uid: Option<i64>,
    /// User defined unique identifier
    pub(crate) identifier: String,
    /// An array of user-defined tags to organize the Enums
    pub(crate) tags: Vec<String>,
    /// Unique Int identifier
    pub(crate) uid: i64,
    /// All possible enum values, with their optional Tile infos.
    pub(crate) values: Vec<EnumValueDefinition>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct EnumValueDefinition {
    /// **WARNING**: this deprecated value is no longer exported since version 1.4.0  Replaced
    /// by: `tileRect`
    #[serde(rename = "__tileSrcRect")]
    pub(crate) tile_src_rect: Option<Vec<i64>>,
    /// Optional color
    pub(crate) color: i64,
    /// Enum value
    pub(crate) id: String,
    /// **WARNING**: this deprecated value is no longer exported since version 1.4.0  Replaced
    /// by: `tileRect`
    pub(crate) tile_id: Option<i64>,
    /// Optional tileset rectangle to represents this value
    pub(crate) tile_rect: Option<TilesetRectangle>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LayerDefinition {
    /// Type of the layer (*IntGrid, Entities, Tiles or AutoLayer*)
    #[serde(rename = "__type")]
    pub(crate) layer_definition_type: String,
    /// Contains all the auto-layer rule definitions.
    pub(crate) auto_rule_groups: Vec<AutoLayerRuleGroup>,
    pub(crate) auto_source_layer_def_uid: Option<i64>,
    /// **WARNING**: this deprecated value is no longer exported since version 1.2.0  Replaced
    /// by: `tilesetDefUid`
    pub(crate) auto_tileset_def_uid: Option<i64>,
    pub(crate) auto_tiles_killed_by_other_layer_uid: Option<i64>,
    pub(crate) biome_field_uid: Option<i64>,
    /// Allow editor selections when the layer is not currently active.
    pub(crate) can_select_when_inactive: bool,
    /// Opacity of the layer (0 to 1.0)
    pub(crate) display_opacity: f64,
    /// User defined documentation for this element to provide help/tips to level designers.
    pub(crate) doc: Option<String>,
    /// An array of tags to forbid some Entities in this layer
    pub(crate) excluded_tags: Vec<String>,
    /// Width and height of the grid in pixels
    pub(crate) grid_size: i64,
    /// Height of the optional "guide" grid in pixels
    pub(crate) guide_grid_hei: i64,
    /// Width of the optional "guide" grid in pixels
    pub(crate) guide_grid_wid: i64,
    pub(crate) hide_fields_when_inactive: bool,
    /// Hide the layer from the list on the side of the editor view.
    pub(crate) hide_in_list: bool,
    /// User defined unique identifier
    pub(crate) identifier: String,
    /// Alpha of this layer when it is not the active one.
    pub(crate) inactive_opacity: f64,
    /// An array that defines extra optional info for each IntGrid value.<br/>  WARNING: the
    /// array order is not related to actual IntGrid values! As user can re-order IntGrid values
    /// freely, you may value "2" before value "1" in this array.
    pub(crate) int_grid_values: Vec<IntGridValueDefinition>,
    /// Group informations for IntGrid values
    pub(crate) int_grid_values_groups: Vec<IntGridValueGroupDefinition>,
    /// Parallax horizontal factor (from -1 to 1, defaults to 0) which affects the scrolling
    /// speed of this layer, creating a fake 3D (parallax) effect.
    pub(crate) parallax_factor_x: f64,
    /// Parallax vertical factor (from -1 to 1, defaults to 0) which affects the scrolling speed
    /// of this layer, creating a fake 3D (parallax) effect.
    pub(crate) parallax_factor_y: f64,
    /// If true (default), a layer with a parallax factor will also be scaled up/down accordingly.
    pub(crate) parallax_scaling: bool,
    /// X offset of the layer, in pixels (IMPORTANT: this should be added to the `LayerInstance`
    /// optional offset)
    pub(crate) px_offset_x: i64,
    /// Y offset of the layer, in pixels (IMPORTANT: this should be added to the `LayerInstance`
    /// optional offset)
    pub(crate) px_offset_y: i64,
    /// If TRUE, the content of this layer will be used when rendering levels in a simplified way
    /// for the world view
    pub(crate) render_in_world_view: bool,
    /// An array of tags to filter Entities that can be added to this layer
    pub(crate) required_tags: Vec<String>,
    /// If the tiles are smaller or larger than the layer grid, the pivot value will be used to
    /// position the tile relatively its grid cell.
    pub(crate) tile_pivot_x: f64,
    /// If the tiles are smaller or larger than the layer grid, the pivot value will be used to
    /// position the tile relatively its grid cell.
    pub(crate) tile_pivot_y: f64,
    /// Reference to the default Tileset UID being used by this layer definition.<br/>
    /// **WARNING**: some layer *instances* might use a different tileset. So most of the time,
    /// you should probably use the `__tilesetDefUid` value found in layer instances.<br/>  Note:
    /// since version 1.0.0, the old `autoTilesetDefUid` was removed and merged into this value.
    pub(crate) tileset_def_uid: Option<i64>,
    /// Type of the layer as Haxe Enum Possible values: `IntGrid`, `Entities`, `Tiles`,
    /// `AutoLayer`
    #[serde(rename = "type")]
    pub(crate) purple_type: Type,
    /// User defined color for the UI
    pub(crate) ui_color: Option<String>,
    /// Unique Int identifier
    pub(crate) uid: i64,
    /// Display tags
    pub(crate) ui_filter_tags: Vec<String>,
    /// Asynchronous rendering option for large/complex layers
    pub(crate) use_async_render: bool,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AutoLayerRuleGroup {
    pub(crate) active: bool,
    pub(crate) biome_requirement_mode: i64,
    /// *This field was removed in 1.0.0 and should no longer be used.*
    pub(crate) collapsed: Option<bool>,
    pub(crate) color: Option<String>,
    pub(crate) icon: Option<TilesetRectangle>,
    pub(crate) is_optional: bool,
    pub(crate) name: String,
    pub(crate) required_biome_values: Vec<String>,
    pub(crate) rules: Vec<AutoLayerRuleDefinition>,
    pub(crate) uid: i64,
    pub(crate) uses_wizard: bool,
}
/// This complex section isn't meant to be used by game devs at all, as these rules are
/// completely resolved internally by the editor before any saving. You should just ignore
/// this part.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct AutoLayerRuleDefinition {
    /// If FALSE, the rule effect isn't applied, and no tiles are generated.
    pub(crate) active: bool,
    pub(crate) alpha: f64,
    /// When TRUE, the rule will prevent other rules to be applied in the same cell if it matches
    /// (TRUE by default).
    pub(crate) break_on_match: bool,
    /// Chances for this rule to be applied (0 to 1)
    pub(crate) chance: f64,
    /// Checker mode Possible values: `None`, `Horizontal`, `Vertical`
    pub(crate) checker: Checker,
    /// If TRUE, allow rule to be matched by flipping its pattern horizontally
    pub(crate) flip_x: bool,
    /// If TRUE, allow rule to be matched by flipping its pattern vertically
    pub(crate) flip_y: bool,
    /// If TRUE, then the rule should be re-evaluated by the editor at one point
    pub(crate) invalidated: bool,
    /// Default IntGrid value when checking cells outside of level bounds
    pub(crate) out_of_bounds_value: Option<i64>,
    /// Rule pattern (size x size)
    pub(crate) pattern: Vec<i64>,
    /// If TRUE, enable Perlin filtering to only apply rule on specific random area
    pub(crate) perlin_active: bool,
    pub(crate) perlin_octaves: f64,
    pub(crate) perlin_scale: f64,
    pub(crate) perlin_seed: f64,
    /// X pivot of a tile stamp (0-1)
    pub(crate) pivot_x: f64,
    /// Y pivot of a tile stamp (0-1)
    pub(crate) pivot_y: f64,
    /// Pattern width & height. Should only be 1,3,5 or 7.
    pub(crate) size: i64,
    /// **WARNING**: this deprecated value is no longer exported since version 1.5.0  Replaced
    /// by: `tileRectsIds`
    pub(crate) tile_ids: Option<Vec<i64>>,
    /// Defines how tileIds array is used Possible values: `Single`, `Stamp`
    pub(crate) tile_mode: TileMode,
    /// Max random offset for X tile pos
    pub(crate) tile_random_x_max: i64,
    /// Min random offset for X tile pos
    pub(crate) tile_random_x_min: i64,
    /// Max random offset for Y tile pos
    pub(crate) tile_random_y_max: i64,
    /// Min random offset for Y tile pos
    pub(crate) tile_random_y_min: i64,
    /// Array containing all the possible tile IDs rectangles (picked randomly).
    pub(crate) tile_rects_ids: Vec<Vec<i64>>,
    /// Tile X offset
    pub(crate) tile_x_offset: i64,
    /// Tile Y offset
    pub(crate) tile_y_offset: i64,
    /// Unique Int identifier
    pub(crate) uid: i64,
    /// X cell coord modulo
    pub(crate) x_modulo: i64,
    /// X cell start offset
    pub(crate) x_offset: i64,
    /// Y cell coord modulo
    pub(crate) y_modulo: i64,
    /// Y cell start offset
    pub(crate) y_offset: i64,
}
/// Checker mode Possible values: `None`, `Horizontal`, `Vertical`
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum Checker {
    Horizontal,
    None,
    Vertical,
}
/// Defines how tileIds array is used Possible values: `Single`, `Stamp`
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum TileMode {
    Single,
    Stamp,
}
/// IntGrid value definition
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct IntGridValueDefinition {
    pub(crate) color: String,
    /// Parent group identifier (0 if none)
    pub(crate) group_uid: i64,
    /// User defined unique identifier
    pub(crate) identifier: Option<String>,
    pub(crate) tile: Option<TilesetRectangle>,
    /// The IntGrid value itself
    pub(crate) value: i64,
}
/// IntGrid value group definition
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct IntGridValueGroupDefinition {
    /// User defined color
    pub(crate) color: Option<String>,
    /// User defined string identifier
    pub(crate) identifier: Option<String>,
    /// Group unique ID
    pub(crate) uid: i64,
}
/// Type of the layer as Haxe Enum Possible values: `IntGrid`, `Entities`, `Tiles`,
/// `AutoLayer`
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum Type {
    #[serde(rename = "AutoLayer")]
    AutoLayer,
    Entities,
    #[serde(rename = "IntGrid")]
    IntGrid,
    Tiles,
}
/// The `Tileset` definition is the most important part among project definitions. It
/// contains some extra informations about each integrated tileset. If you only had to parse
/// one definition section, that would be the one.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TilesetDefinition {
    /// Grid-based height
    #[serde(rename = "__cHei")]
    pub(crate) c_hei: i64,
    /// Grid-based width
    #[serde(rename = "__cWid")]
    pub(crate) c_wid: i64,
    /// The following data is used internally for various optimizations. It's always synced with
    /// source image changes.
    pub(crate) cached_pixel_data: Option<HashMap<String, Option<serde_json::Value>>>,
    /// An array of custom tile metadata
    pub(crate) custom_data: Vec<TileCustomMetadata>,
    /// If this value is set, then it means that this atlas uses an internal LDtk atlas image
    /// instead of a loaded one. Possible values: &lt;`null`&gt;, `LdtkIcons`
    pub(crate) embed_atlas: Option<EmbedAtlas>,
    /// Tileset tags using Enum values specified by `tagsSourceEnumId`. This array contains 1
    /// element per Enum value, which contains an array of all Tile IDs that are tagged with it.
    pub(crate) enum_tags: Vec<EnumTagValue>,
    /// User defined unique identifier
    pub(crate) identifier: String,
    /// Distance in pixels from image borders
    pub(crate) padding: i64,
    /// Image height in pixels
    pub(crate) px_hei: i64,
    /// Image width in pixels
    pub(crate) px_wid: i64,
    /// Path to the source file, relative to the current project JSON file<br/>  It can be null
    /// if no image was provided, or when using an embed atlas.
    pub(crate) rel_path: Option<String>,
    /// Array of group of tiles selections, only meant to be used in the editor
    pub(crate) saved_selections: Vec<HashMap<String, Option<serde_json::Value>>>,
    /// Space in pixels between all tiles
    pub(crate) spacing: i64,
    /// An array of user-defined tags to organize the Tilesets
    pub(crate) tags: Vec<String>,
    /// Optional Enum definition UID used for this tileset meta-data
    pub(crate) tags_source_enum_uid: Option<i64>,
    pub(crate) tile_grid_size: i64,
    /// Unique Intidentifier
    pub(crate) uid: i64,
}
/// In a tileset definition, user defined meta-data of a tile.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TileCustomMetadata {
    pub(crate) data: String,
    pub(crate) tile_id: i64,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum EmbedAtlas {
    #[serde(rename = "LdtkIcons")]
    LdtkIcons,
}
/// In a tileset definition, enum based tag infos
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct EnumTagValue {
    pub(crate) enum_value_id: String,
    pub(crate) tile_ids: Vec<i64>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum Flag {
    #[serde(rename = "DiscardPreCsvIntGrid")]
    DiscardPreCsvIntGrid,
    #[serde(rename = "ExportOldTableOfContentData")]
    ExportOldTableOfContentData,
    #[serde(rename = "ExportPreCsvIntGridFormat")]
    ExportPreCsvIntGridFormat,
    #[serde(rename = "IgnoreBackupSuggest")]
    IgnoreBackupSuggest,
    #[serde(rename = "MultiWorlds")]
    MultiWorlds,
    #[serde(rename = "PrependIndexToLevelFileNames")]
    PrependIndexToLevelFileNames,
    #[serde(rename = "UseMultilinesType")]
    UseMultilinesType,
}
/// This object is not actually used by LDtk. It ONLY exists to force explicit references to
/// all types, to make sure QuickType finds them and integrate all of them. Otherwise,
/// Quicktype will drop types that are not explicitely used.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
pub struct ForcedRefs {
    pub(crate) auto_layer_rule_group: Option<AutoLayerRuleGroup>,
    pub(crate) auto_rule_def: Option<AutoLayerRuleDefinition>,
    pub(crate) custom_command: Option<LdtkCustomCommand>,
    pub(crate) definitions: Option<Definitions>,
    pub(crate) entity_def: Option<EntityDefinition>,
    pub(crate) entity_instance: Option<EntityInstance>,
    pub(crate) entity_reference_infos: Option<ReferenceToAnEntityInstance>,
    pub(crate) enum_def: Option<EnumDefinition>,
    pub(crate) enum_def_values: Option<EnumValueDefinition>,
    pub(crate) enum_tag_value: Option<EnumTagValue>,
    pub(crate) field_def: Option<FieldDefinition>,
    pub(crate) field_instance: Option<FieldInstance>,
    pub(crate) grid_point: Option<GridPoint>,
    pub(crate) int_grid_value_def: Option<IntGridValueDefinition>,
    pub(crate) int_grid_value_group_def: Option<IntGridValueGroupDefinition>,
    pub(crate) int_grid_value_instance: Option<IntGridValueInstance>,
    pub(crate) layer_def: Option<LayerDefinition>,
    pub(crate) layer_instance: Option<LayerInstance>,
    pub(crate) level: Option<Level>,
    pub(crate) level_bg_pos_infos: Option<LevelBackgroundPosition>,
    pub(crate) neighbour_level: Option<NeighbourLevel>,
    pub(crate) table_of_content_entry: Option<LdtkTableOfContentEntry>,
    pub(crate) tile: Option<TileInstance>,
    pub(crate) tile_custom_metadata: Option<TileCustomMetadata>,
    pub(crate) tileset_def: Option<TilesetDefinition>,
    pub(crate) tileset_rect: Option<TilesetRectangle>,
    pub(crate) toc_instance_data: Option<LdtkTocInstanceData>,
    pub(crate) world: Option<World>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct EntityInstance {
    /// Grid-based coordinates (`[x,y]` format)
    #[serde(rename = "__grid")]
    pub(crate) grid: Vec<i64>,
    /// Entity definition identifier
    #[serde(rename = "__identifier")]
    pub(crate) identifier: String,
    /// Pivot coordinates  (`[x,y]` format, values are from 0 to 1) of the Entity
    #[serde(rename = "__pivot")]
    pub(crate) pivot: Vec<f64>,
    /// The entity "smart" color, guessed from either Entity definition, or one its field
    /// instances.
    #[serde(rename = "__smartColor")]
    pub(crate) smart_color: String,
    /// Array of tags defined in this Entity definition
    #[serde(rename = "__tags")]
    pub(crate) tags: Vec<String>,
    /// Optional TilesetRect used to display this entity (it could either be the default Entity
    /// tile, or some tile provided by a field value, like an Enum).
    #[serde(rename = "__tile")]
    pub(crate) tile: Option<TilesetRectangle>,
    /// X world coordinate in pixels. Only available in GridVania or Free world layouts.
    #[serde(rename = "__worldX")]
    pub(crate) world_x: Option<i64>,
    /// Y world coordinate in pixels Only available in GridVania or Free world layouts.
    #[serde(rename = "__worldY")]
    pub(crate) world_y: Option<i64>,
    /// Reference of the **Entity definition** UID
    pub(crate) def_uid: i64,
    /// An array of all custom fields and their values.
    pub(crate) field_instances: Vec<FieldInstance>,
    /// Entity height in pixels. For non-resizable entities, it will be the same as Entity
    /// definition.
    pub(crate) height: i64,
    /// Unique instance identifier
    pub(crate) iid: String,
    /// Pixel coordinates (`[x,y]` format) in current level coordinate space. Don't forget
    /// optional layer offsets, if they exist!
    pub(crate) px: Vec<i64>,
    /// Entity width in pixels. For non-resizable entities, it will be the same as Entity
    /// definition.
    pub(crate) width: i64,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct FieldInstance {
    /// Field definition identifier
    #[serde(rename = "__identifier")]
    pub(crate) identifier: String,
    /// Optional TilesetRect used to display this field (this can be the field own Tile, or some
    /// other Tile guessed from the value, like an Enum).
    #[serde(rename = "__tile")]
    pub(crate) tile: Option<TilesetRectangle>,
    /// Type of the field, such as `Int`, `Float`, `String`, `Enum(my_enum_name)`, `Bool`,
    /// etc.<br/>  NOTE: if you enable the advanced option **Use Multilines type**, you will have
    /// "*Multilines*" instead of "*String*" when relevant.
    #[serde(rename = "__type")]
    pub(crate) field_instance_type: String,
    /// Actual value of the field instance. The value type varies, depending on `__type`:<br/>
    /// - For **classic types** (ie. Integer, Float, Boolean, String, Text and FilePath), you
    /// just get the actual value with the expected type.<br/>   - For **Color**, the value is an
    /// hexadecimal string using "#rrggbb" format.<br/>   - For **Enum**, the value is a String
    /// representing the selected enum value.<br/>   - For **Point**, the value is a
    /// [GridPoint](#ldtk-GridPoint) object.<br/>   - For **Tile**, the value is a
    /// [TilesetRect](#ldtk-TilesetRect) object.<br/>   - For **EntityRef**, the value is an
    /// [EntityReferenceInfos](#ldtk-EntityReferenceInfos) object.<br/><br/>  If the field is an
    /// array, then this `__value` will also be a JSON array.
    #[serde(rename = "__value")]
    pub(crate) value: Option<serde_json::Value>,
    /// Reference of the **Field definition** UID
    pub(crate) def_uid: i64,
    /// Editor internal raw values
    pub(crate) real_editor_values: Vec<Option<serde_json::Value>>,
}
/// This object describes the "location" of an Entity instance in the project worlds.
///
/// IID information of this instance
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ReferenceToAnEntityInstance {
    /// IID of the refered EntityInstance
    pub(crate) entity_iid: String,
    /// IID of the LayerInstance containing the refered EntityInstance
    pub(crate) layer_iid: String,
    /// IID of the Level containing the refered EntityInstance
    pub(crate) level_iid: String,
    /// IID of the World containing the refered EntityInstance
    pub(crate) world_iid: String,
}
/// This object is just a grid-based coordinate used in Field values.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct GridPoint {
    /// X grid-based coordinate
    pub(crate) cx: i64,
    /// Y grid-based coordinate
    pub(crate) cy: i64,
}
/// IntGrid value instance
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct IntGridValueInstance {
    /// Coordinate ID in the layer grid
    pub(crate) coord_id: i64,
    /// IntGrid value
    pub(crate) v: i64,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LayerInstance {
    /// Grid-based height
    #[serde(rename = "__cHei")]
    pub(crate) c_hei: i64,
    /// Grid-based width
    #[serde(rename = "__cWid")]
    pub(crate) c_wid: i64,
    /// Grid size
    #[serde(rename = "__gridSize")]
    pub(crate) grid_size: i64,
    /// Layer definition identifier
    #[serde(rename = "__identifier")]
    pub(crate) identifier: String,
    /// Layer opacity as Float [0-1]
    #[serde(rename = "__opacity")]
    pub(crate) opacity: f64,
    /// Total layer X pixel offset, including both instance and definition offsets.
    #[serde(rename = "__pxTotalOffsetX")]
    pub(crate) px_total_offset_x: i64,
    /// Total layer Y pixel offset, including both instance and definition offsets.
    #[serde(rename = "__pxTotalOffsetY")]
    pub(crate) px_total_offset_y: i64,
    /// The definition UID of corresponding Tileset, if any.
    #[serde(rename = "__tilesetDefUid")]
    pub(crate) tileset_def_uid: Option<i64>,
    /// The relative path to corresponding Tileset, if any.
    #[serde(rename = "__tilesetRelPath")]
    pub(crate) tileset_rel_path: Option<String>,
    /// Layer type (possible values: IntGrid, Entities, Tiles or AutoLayer)
    #[serde(rename = "__type")]
    pub(crate) layer_instance_type: String,
    /// An array containing all tiles generated by Auto-layer rules. The array is already sorted
    /// in display order (ie. 1st tile is beneath 2nd, which is beneath 3rd etc.).<br/><br/>
    /// Note: if multiple tiles are stacked in the same cell as the result of different rules,
    /// all tiles behind opaque ones will be discarded.
    pub(crate) auto_layer_tiles: Vec<TileInstance>,
    pub(crate) entity_instances: Vec<EntityInstance>,
    pub(crate) grid_tiles: Vec<TileInstance>,
    /// Unique layer instance identifier
    pub(crate) iid: String,
    /// **WARNING**: this deprecated value is no longer exported since version 1.0.0  Replaced
    /// by: `intGridCsv`
    pub(crate) int_grid: Option<Vec<IntGridValueInstance>>,
    /// A list of all values in the IntGrid layer, stored in CSV format (Comma Separated
    /// Values).<br/>  Order is from left to right, and top to bottom (ie. first row from left to
    /// right, followed by second row, etc).<br/>  `0` means "empty cell" and IntGrid values
    /// start at 1.<br/>  The array size is `__cWid` x `__cHei` cells.
    pub(crate) int_grid_csv: Vec<i64>,
    /// Reference the Layer definition UID
    pub(crate) layer_def_uid: i64,
    /// Reference to the UID of the level containing this layer instance
    pub(crate) level_id: i64,
    /// An Array containing the UIDs of optional rules that were enabled in this specific layer
    /// instance.
    pub(crate) optional_rules: Vec<i64>,
    /// This layer can use another tileset by overriding the tileset UID here.
    pub(crate) override_tileset_uid: Option<i64>,
    /// X offset in pixels to render this layer, usually 0 (IMPORTANT: this should be added to
    /// the `LayerDef` optional offset, so you should probably prefer using `__pxTotalOffsetX`
    /// which contains the total offset value)
    pub(crate) px_offset_x: i64,
    /// Y offset in pixels to render this layer, usually 0 (IMPORTANT: this should be added to
    /// the `LayerDef` optional offset, so you should probably prefer using `__pxTotalOffsetX`
    /// which contains the total offset value)
    pub(crate) px_offset_y: i64,
    /// Random seed used for Auto-Layers rendering
    pub(crate) seed: i64,
    /// Layer instance visibility
    pub(crate) visible: bool,
}
/// This structure represents a single tile from a given Tileset.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub struct TileInstance {
    /// Alpha/opacity of the tile (0-1, defaults to 1)
    pub(crate) a: f64,
    /// Internal data used by the editor.<br/>  For auto-layer tiles: `[ruleId, coordId]`.<br/>
    /// For tile-layer tiles: `[coordId]`.
    pub(crate) d: Vec<i64>,
    /// "Flip bits", a 2-bits integer to represent the mirror transformations of the tile.<br/>
    /// - Bit 0 = X flip<br/>   - Bit 1 = Y flip<br/>   Examples: f=0 (no flip), f=1 (X flip
    /// only), f=2 (Y flip only), f=3 (both flips)
    pub(crate) f: i64,
    /// Pixel coordinates of the tile in the **layer** (`[x,y]` format). Don't forget optional
    /// layer offsets, if they exist!
    pub(crate) px: Vec<i64>,
    /// Pixel coordinates of the tile in the **tileset** (`[x,y]` format)
    pub(crate) src: Vec<i64>,
    /// The *Tile ID* in the corresponding tileset.
    pub(crate) t: i64,
}
/// This section contains all the level data. It can be found in 2 distinct forms, depending
/// on Project current settings:  - If "*Separate level files*" is **disabled** (default):
/// full level data is *embedded* inside the main Project JSON file, - If "*Separate level
/// files*" is **enabled**: level data is stored in *separate* standalone `.ldtkl` files (one
/// per level). In this case, the main Project JSON file will still contain most level data,
/// except heavy sections, like the `layerInstances` array (which will be null). The
/// `externalRelPath` string points to the `ldtkl` file.  A `ldtkl` file is just a JSON file
/// containing exactly what is described below.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct Level {
    /// Background color of the level (same as `bgColor`, except the default value is
    /// automatically used here if its value is `null`)
    #[serde(rename = "__bgColor")]
    pub(crate) bg_color: String,
    /// Position informations of the background image, if there is one.
    #[serde(rename = "__bgPos")]
    pub(crate) bg_pos: Option<LevelBackgroundPosition>,
    /// An array listing all other levels touching this one on the world map. Since 1.4.0, this
    /// includes levels that overlap in the same world layer, or in nearby world layers.<br/>
    /// Only relevant for world layouts where level spatial positioning is manual (ie. GridVania,
    /// Free). For Horizontal and Vertical layouts, this array is always empty.
    #[serde(rename = "__neighbours")]
    pub(crate) neighbours: Vec<NeighbourLevel>,
    /// The "guessed" color for this level in the editor, decided using either the background
    /// color or an existing custom field.
    #[serde(rename = "__smartColor")]
    pub(crate) smart_color: String,
    /// Background color of the level. If `null`, the project `defaultLevelBgColor` should be
    /// used.
    #[serde(rename = "bgColor")]
    pub(crate) level_bg_color: Option<String>,
    /// Background image X pivot (0-1)
    pub(crate) bg_pivot_x: f64,
    /// Background image Y pivot (0-1)
    pub(crate) bg_pivot_y: f64,
    /// An enum defining the way the background image (if any) is positioned on the level. See
    /// `__bgPos` for resulting position info. Possible values: &lt;`null`&gt;, `Unscaled`,
    /// `Contain`, `Cover`, `CoverDirty`, `Repeat`
    #[serde(rename = "bgPos")]
    pub(crate) level_bg_pos: Option<BgPos>,
    /// The *optional* relative path to the level background image.
    pub(crate) bg_rel_path: Option<String>,
    /// This value is not null if the project option "*Save levels separately*" is enabled. In
    /// this case, this **relative** path points to the level Json file.
    pub(crate) external_rel_path: Option<String>,
    /// An array containing this level custom field values.
    pub(crate) field_instances: Vec<FieldInstance>,
    /// User defined unique identifier
    pub(crate) identifier: String,
    /// Unique instance identifier
    pub(crate) iid: String,
    /// An array containing all Layer instances. **IMPORTANT**: if the project option "*Save
    /// levels separately*" is enabled, this field will be `null`.<br/>  This array is **sorted
    /// in display order**: the 1st layer is the top-most and the last is behind.
    pub(crate) layer_instances: Option<Vec<LayerInstance>>,
    /// Height of the level in pixels
    pub(crate) px_hei: i64,
    /// Width of the level in pixels
    pub(crate) px_wid: i64,
    /// Unique Int identifier
    pub(crate) uid: i64,
    /// If TRUE, the level identifier will always automatically use the naming pattern as defined
    /// in `Project.levelNamePattern`. Becomes FALSE if the identifier is manually modified by
    /// user.
    pub(crate) use_auto_identifier: bool,
    /// Index that represents the "depth" of the level in the world. Default is 0, greater means
    /// "above", lower means "below".<br/>  This value is mostly used for display only and is
    /// intended to make stacking of levels easier to manage.
    pub(crate) world_depth: i64,
    /// World X coordinate in pixels.<br/>  Only relevant for world layouts where level spatial
    /// positioning is manual (ie. GridVania, Free). For Horizontal and Vertical layouts, the
    /// value is always -1 here.
    pub(crate) world_x: i64,
    /// World Y coordinate in pixels.<br/>  Only relevant for world layouts where level spatial
    /// positioning is manual (ie. GridVania, Free). For Horizontal and Vertical layouts, the
    /// value is always -1 here.
    pub(crate) world_y: i64,
}
/// Level background image position info
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LevelBackgroundPosition {
    /// An array of 4 float values describing the cropped sub-rectangle of the displayed
    /// background image. This cropping happens when original is larger than the level bounds.
    /// Array format: `[ cropX, cropY, cropWidth, cropHeight ]`
    pub(crate) crop_rect: Vec<f64>,
    /// An array containing the `[scaleX,scaleY]` values of the **cropped** background image,
    /// depending on `bgPos` option.
    pub(crate) scale: Vec<f64>,
    /// An array containing the `[x,y]` pixel coordinates of the top-left corner of the
    /// **cropped** background image, depending on `bgPos` option.
    pub(crate) top_left_px: Vec<i64>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum BgPos {
    Contain,
    Cover,
    #[serde(rename = "CoverDirty")]
    CoverDirty,
    Repeat,
    Unscaled,
}
/// Nearby level info
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct NeighbourLevel {
    /// A lowercase string tipping on the level location (`n`orth, `s`outh, `w`est,
    /// `e`ast).<br/>  Since 1.4.0, this value can also be `<` (neighbour depth is lower), `>`
    /// (neighbour depth is greater) or `o` (levels overlap and share the same world
    /// depth).<br/>  Since 1.5.3, this value can also be `nw`,`ne`,`sw` or `se` for levels only
    /// touching corners.
    pub(crate) dir: String,
    /// Neighbour Instance Identifier
    pub(crate) level_iid: String,
    /// **WARNING**: this deprecated value is no longer exported since version 1.2.0  Replaced
    /// by: `levelIid`
    pub(crate) level_uid: Option<i64>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LdtkTableOfContentEntry {
    pub(crate) identifier: String,
    /// **WARNING**: this deprecated value will be *removed* completely on version 1.7.0+
    /// Replaced by: `instancesData`
    pub(crate) instances: Option<Vec<ReferenceToAnEntityInstance>>,
    pub(crate) instances_data: Vec<LdtkTocInstanceData>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct LdtkTocInstanceData {
    /// An object containing the values of all entity fields with the `exportToToc` option
    /// enabled. This object typing depends on actual field value types.
    pub(crate) fields: Option<serde_json::Value>,
    pub(crate) hei_px: i64,
    /// IID information of this instance
    pub(crate) iids: ReferenceToAnEntityInstance,
    pub(crate) wid_px: i64,
    pub(crate) world_x: i64,
    pub(crate) world_y: i64,
}
/// **IMPORTANT**: this type is available as a preview. You can rely on it to update your
/// importers, for when it will be officially available.  A World contains multiple levels,
/// and it has its own layout settings.
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct World {
    /// Default new level height
    pub(crate) default_level_height: i64,
    /// Default new level width
    pub(crate) default_level_width: i64,
    /// User defined unique identifier
    pub(crate) identifier: String,
    /// Unique instance identifer
    pub(crate) iid: String,
    /// All levels from this world. The order of this array is only relevant in
    /// `LinearHorizontal` and `linearVertical` world layouts (see `worldLayout` value).
    /// Otherwise, you should refer to the `worldX`,`worldY` coordinates of each Level.
    pub(crate) levels: Vec<Level>,
    /// Height of the world grid in pixels.
    pub(crate) world_grid_height: i64,
    /// Width of the world grid in pixels.
    pub(crate) world_grid_width: i64,
    /// An enum that describes how levels are organized in this project (ie. linearly or in a 2D
    /// space). Possible values: `Free`, `GridVania`, `LinearHorizontal`, `LinearVertical`, `null`
    pub(crate) world_layout: Option<WorldLayout>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum WorldLayout {
    Free,
    #[serde(rename = "GridVania")]
    GridVania,
    #[serde(rename = "LinearHorizontal")]
    LinearHorizontal,
    #[serde(rename = "LinearVertical")]
    LinearVertical,
}
/// Naming convention for Identifiers (first-letter uppercase, full uppercase etc.) Possible
/// values: `Capitalize`, `Uppercase`, `Lowercase`, `Free`
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum IdentifierStyle {
    Capitalize,
    Free,
    Lowercase,
    Uppercase,
}
/// "Image export" option when saving project. Possible values: `None`, `OneImagePerLayer`,
/// `OneImagePerLevel`, `LayersAndLevels`
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
pub enum ImageExportMode {
    #[serde(rename = "LayersAndLevels")]
    LayersAndLevels,
    None,
    #[serde(rename = "OneImagePerLayer")]
    OneImagePerLayer,
    #[serde(rename = "OneImagePerLevel")]
    OneImagePerLevel,
}
#[allow(clippy::enum_variant_names)]

use std::sync::Arc;

use assets_manager::{
    loader::{BytesLoader, LoadFrom, RonLoader},
    Asset, AssetCache,
};
use cosmic_text::fontdb::FaceInfo;

    fontdb::Source, Attrs, Buffer, Color, FontSystem, Metrics, Shaping, SwashCache, TextArea,
    TextBounds,

    Attrs, Buffer, Color, FontSystem, Metrics, Shaping, SwashCache, TextArea, TextBounds,

    pub fn new<S: assets_manager::source::Source>(
        assets: &AssetCache<S>,
    ) -> color_eyre::Result<Self> {
        let fonts_handle = assets.load_rec_dir::<FontData>("fonts")?;
        let fonts: Vec<_> = fonts_handle
            .read()
            .iter(assets)
            .filter_map(|maybe_font| match maybe_font {
                Ok(font_handle) => {
                    let font_data: Arc<Vec<u8>> = Arc::new(font_handle.read().0.clone());
                    let id = font_handle.id();
                    Some((id, Source::Binary(font_data)))
                }
                Err(e) => {
                    log::info!("failed to recursively load a font: {e}");
                    None
                }
            })
            .collect();

    pub fn new() -> color_eyre::Result<Self> {

        for (asset_id, source) in fonts.into_iter() {
            let ids = db.load_font_source(source);
            log::warn!("loaded {asset_id} into {ids}");
            let font_info = ids.iter().find_map(|id| db.face(*id));
            if font_info
                .expect("fontdb failed to load faces from {asset_id}")
                .monospaced
            {
                log::warn!("{asset_id} is monospaced");
            }
            // Change emoji to monospaced?
            for face_info in ids
                .into_iter()
                .filter_map(|id| db.face(id).cloned())
                .collect::<Vec<_>>()
            {
                let FaceInfo {
                    ref families,
                    ref post_script_name,
                    ref style,
                    ref monospaced,
                    ref weight,
                    ref stretch,
                    ..
                } = face_info;
                log::warn!(
                    "{families:?} {post_script_name} {style:?} {monospaced} {weight:?} {stretch:?}"
                );
                // face_info.monospaced = true;
                // face_info.id = ID::dummy();
                // db.push_face_info(face_info);
            }
        }

struct FontData(Vec<u8>);

impl From<Vec<u8>> for FontData {
    fn from(value: Vec<u8>) -> Self {
        Self(value)
    }
}
impl Asset for FontData {
    const EXTENSIONS: &'static [&'static str] = &["ttf"];
    type Loader = LoadFrom<Vec<u8>, BytesLoader>;
}

#[derive(serde::Deserialize, Debug, Clone)]
struct Text {
    font_size: f32,
    #[serde(default)]
    text_dims: Option<glam::Vec2>,
    text: String,
    #[serde(default)]
    position: Option<glam::Vec2>,
    #[serde(default)]
    scale: Option<f32>,
    #[serde(default)]
    color: Option<TextColor>,
    #[serde(default)]
    lines: Option<usize>,
}
#[derive(serde::Deserialize)]
struct TextList(Vec<Text>);
impl Asset for TextList {
    const EXTENSION: &'static str = "textl";

    type Loader = RonLoader;
}

    pub fn prepare<S: assets_manager::source::Source>(
        &mut self,
        _data: &TextSystemData,
        _assets: &AssetCache<S>,
    ) {
    }

    pub fn prepare(&mut self, _data: &TextSystemData) {}

    pub fn produce_world<S: assets_manager::source::Source>(

    pub fn produce_world(

        assets: &AssetCache<S>,

        let Ok(world_text) = assets.load::<TextList>("text_data.world") else {
            let metrics = Metrics::new(32.0, 20.0);
            let mut buffer = Buffer::new(&mut self.fonts, metrics);
            {
                let mut buffer = buffer.borrow_with(&mut self.fonts);
                buffer.set_size(250.0, 25.0);
                let attrs = Attrs::new().family(glyphon::Family::Name("Poiret One"));
                buffer.set_text("Hello, game! 🦀\n", attrs, Shaping::Advanced);
                buffer.shape_until_scroll(true);
            }
            let loc = glam::Vec2::new(32.0, 32.0);
            let mut buffer2 = Buffer::new(&mut self.fonts, metrics);
            {
                let mut buffer2 = buffer2.borrow_with(&mut self.fonts);
                buffer2.set_size(250.0, 25.0);
                let attrs = Attrs::new()
                    .family(glyphon::Family::Name("Poiret One"))
                    .color(glyphon::Color::rgb(255, 255, 255));
                buffer2.set_text("Y tho? 🦀\n", attrs, Shaping::Advanced);
                buffer2.shape_until_scroll(true);
            }
            let loc2 = glam::Vec2::new(32.0, 64.0);
            return vec![
                (
                    buffer,
                    BufferMapper::new(self.convert_world_to_glyphon_world(loc), 1.0),
                ),
                (
                    buffer2,
                    BufferMapper::new(self.convert_world_to_glyphon_world(loc2), 1.0),
                ),
            ];
        };
        world_text
            .read()
            .0
            .iter()
            .map(|text| {
                let metrics = Metrics::new(text.font_size, 20.0);
                let mut buffer = Buffer::new(&mut self.fonts, metrics);
                {
                    let mut buffer = buffer.borrow_with(&mut self.fonts);
                    if let Some(text_dims) = text.text_dims {
                        buffer.set_size(text_dims.x, text_dims.y);
                    }
                    // let attrs = Attrs::new().family(glyphon::Family::Name("Poiret One"));
                    let mut attrs = Attrs::new();
                    if let Some(color) = text.color {
                        let color: palette::Srgba<u8> = color.0.into_format();
                        attrs = attrs.color(glyphon::Color::rgba(
                            color.red,
                            color.green,
                            color.blue,
                            color.alpha,
                        ));
                    }
                    buffer.set_rich_text(
                        [(
                            text.text.as_str(),
                            // attrs.family(glyphon::Family::Name("Noto Color Emoji")),
                            attrs.family(glyphon::Family::Name("Poiret One")),
                        )],
                        attrs,
                        Shaping::Advanced,
                    );
                    for line_idx in 0..text.lines.unwrap_or(1) {
                        buffer.line_shape(line_idx);
                        buffer.line_layout(line_idx);
                    }
                }
                (
                    buffer,
                    BufferMapper::new(
                        self.convert_world_to_glyphon_world(text.position.unwrap_or_default()),
                        text.scale.unwrap_or(1.0),
                    ),
                )
            })
            .collect()

        let metrics = Metrics::new(32.0, 20.0);
        let mut buffer = Buffer::new(&mut self.fonts, metrics);
        {
            let mut buffer = buffer.borrow_with(&mut self.fonts);
            buffer.set_size(250.0, 25.0);
            let attrs = Attrs::new().family(glyphon::Family::Name("Poiret One"));
            buffer.set_text("Hello, game! 🦀\n", attrs, Shaping::Advanced);
            buffer.shape_until_scroll(true);
        }
        let loc = glam::Vec2::new(32.0, 32.0);
        let mut buffer2 = Buffer::new(&mut self.fonts, metrics);
        {
            let mut buffer2 = buffer2.borrow_with(&mut self.fonts);
            buffer2.set_size(250.0, 25.0);
            let attrs = Attrs::new()
                .family(glyphon::Family::Name("Poiret One"))
                .color(glyphon::Color::rgb(255, 255, 255));
            buffer2.set_text("Y tho? 🦀\n", attrs, Shaping::Advanced);
            buffer2.shape_until_scroll(true);
        }
        let loc2 = glam::Vec2::new(32.0, 64.0);
        vec![
            (
                buffer,
                BufferMapper::new(self.convert_world_to_glyphon_world(loc), 1.0),
            ),
            (
                buffer2,
                BufferMapper::new(self.convert_world_to_glyphon_world(loc2), 1.0),
            ),
        ]

    pub fn produce_camera<S: assets_manager::source::Source>(

    pub fn produce_camera(

        assets: &AssetCache<S>,

        let Ok(cam_text) = assets.load::<TextList>("text_data.camera") else {
            let metrics = Metrics::new(32.0, 20.0);
            let mut buffer = Buffer::new(&mut self.fonts, metrics);
            {
                let mut buffer = buffer.borrow_with(&mut self.fonts);
                buffer.set_size(200.0, 25.0);
                let attrs = Attrs::new().family(glyphon::Family::Name("Poiret One"));
                buffer.set_text("Hello, Rust! 🦀\n", attrs, Shaping::Advanced);
                buffer.shape_until_scroll(true);
            }
            return vec![(buffer, BufferMapper::new((32.0, 32.0).into(), 1.0))];
        };
        cam_text
            .read()
            .0
            .iter()
            .map(|text| {
                let metrics = Metrics::new(text.font_size, 20.0);
                let mut buffer = Buffer::new(&mut self.fonts, metrics);
                {
                    let mut buffer = buffer.borrow_with(&mut self.fonts);
                    if let Some(text_dims) = text.text_dims {
                        buffer.set_size(text_dims.x, text_dims.y);
                    }
                    let attrs = Attrs::new().family(glyphon::Family::Name("Poiret One"));
                    buffer.set_text(
                        &text.text,
                        if let Some(color) = text.color {
                            let color: palette::Srgba<u8> = color.0.into_format();
                            attrs.color(glyphon::Color::rgba(
                                color.red,
                                color.green,
                                color.blue,
                                color.alpha,
                            ))
                        } else {
                            attrs
                        },
                        Shaping::Advanced,
                    );
                    buffer.shape_until_scroll(true);
                }
                (
                    buffer,
                    BufferMapper::new(text.position.unwrap_or_default(), text.scale.unwrap_or(1.0)),
                )
            })
            .collect()

        let metrics = Metrics::new(32.0, 20.0);
        let mut buffer = Buffer::new(&mut self.fonts, metrics);
        {
            let mut buffer = buffer.borrow_with(&mut self.fonts);
            buffer.set_size(200.0, 25.0);
            let attrs = Attrs::new().family(glyphon::Family::Name("Poiret One"));
            buffer.set_text("Hello, Rust! 🦀\n", attrs, Shaping::Advanced);
            buffer.shape_until_scroll(true);
        }
        vec![(buffer, BufferMapper::new((32.0, 32.0).into(), 1.0))]

    pub fn extract(_world: &mut hecs::World) -> Self {

    pub fn extract() -> Self {

use assets_manager::AssetCache;

    pub async fn create_surface<S: assets_manager::source::Source>(
        &mut self,
        assets: &AssetCache<S>,
    ) -> color_eyre::Result<()> {

    pub async fn create_surface(&mut self) -> color_eyre::Result<()> {

            assets,

use assets_manager::AssetCache;

    fn create_composer<S: assets_manager::source::Source>(
        _assets: &AssetCache<S>,
    ) -> Result<compose::Composer, compose::ComposerError> {

    fn create_composer() -> Result<compose::Composer, compose::ComposerError> {

    pub fn new<S: assets_manager::source::Source>(

    pub fn new(

        assets: &AssetCache<S>,

        let mut composer = Self::create_composer(assets)?;

        let mut composer = Self::create_composer()?;

mod ldtk;

    // Pick the assets source
    #[cfg(not(target_arch = "wasm32"))]
    let source = assets_manager::source::FileSystem::new("assets")?;
    #[cfg(target_arch = "wasm32")]
    let source = assets_manager::source::Embedded::from(assets_manager::source::embed!("assets"));
    let assets = Arc::new(assets_manager::AssetCache::with_source(source));
    let game = match Game::new(window, &assets).await {

    let game = match Game::new(window).await {

            if !game.try_lock().unwrap().input(&assets, event) {

            if !game.try_lock().unwrap().input(event) {

                        match game.render(&assets) {

                        match game.render() {

            let assets = assets.clone();

                game.try_lock()
                    .unwrap()
                    .create_surface(&assets)
                    .await
                    .unwrap();

                game.try_lock().unwrap().create_surface().await.unwrap();

                game.update(LOGIC_DURATION, &assets);

                game.update(LOGIC_DURATION);

            // Sync the physics system with the real world *now* (using the remainder of the accumuator as a delta)
            game.physics_sync(accum.as_secs_f32() / LOGIC_DURATION.as_secs_f32());

mod physics;
mod scene;

mod mode;

use assets_manager::AssetCache;

use self::{
    physics::{PhysicsState, PhysicsSystem},
    scene::{Scene, SceneLibrary, SceneReference},
};

use self::mode::{Mode, ModeLibrary, ModeReference};

pub struct Game<S> {

pub struct Game {

    previous_state: PhysicsState,
    current_state: PhysicsState,

    scene_library: ModeLibrary,
    current_scene: Box<dyn Mode + Send>,

    scene_library: SceneLibrary,
    current_scene: Box<dyn Scene<S> + Send>,

    physics: PhysicsSystem,

    pub world: hecs::World,

pub struct GameView<'a, S> {
    pub assets: &'a AssetCache<S>,
    pub world: &'a mut hecs::World,

pub struct GameView<'a> {

    ($game: expr, $assets: expr) => {

    ($game: expr) => {

            assets: $assets,
            world: &mut $game.internal_state.world,

impl<S> Game<S> {
    pub async fn new(window: Window, assets: &AssetCache<S>) -> color_eyre::Result<Self>
    where
        S: assets_manager::source::Source + 'static,
    {
        let scene_library = SceneLibrary;
        let mut world = hecs::World::new();

impl Game {
    pub async fn new(window: Window) -> color_eyre::Result<Self> {
        let scene_library = ModeLibrary;

            assets,
            world: &mut world,

        let mut initial_scene = scene_library.get_scene(&mut view, SceneReference::Init);

        let mut initial_scene = scene_library.get_scene(&mut view, ModeReference::Init);

            // initally empty states
            previous_state: PhysicsState::default(),
            current_state: PhysicsState::default(),
            // executor,

            physics: PhysicsSystem::new(),
            text: TextSystem::new(assets)?,

            text: TextSystem::new()?,

                world,

    pub async fn create_surface(&mut self, assets: &AssetCache<S>) -> color_eyre::Result<()>
    where
        S: assets_manager::source::Source,
    {
        self.screen.create_surface(assets).await

    pub async fn create_surface(&mut self) -> color_eyre::Result<()> {
        self.screen.create_surface().await

    pub fn gui_egui(
        &mut self,
        assets: &AssetCache<S>,
    ) -> (egui::FullOutput, Vec<egui::ClippedPrimitive>) {

    pub fn gui_egui(&mut self) -> (egui::FullOutput, Vec<egui::ClippedPrimitive>) {

            let mut view = extract_view!(self, assets);

            let mut view = extract_view!(self);

    pub fn input(&mut self, assets: &AssetCache<S>, event: &WindowEvent) -> bool {

    pub fn input(&mut self, event: &WindowEvent) -> bool {

        let mut view = extract_view!(self, assets);

        let mut view = extract_view!(self);

    /// Syncs the physics system's results back into the world
    ///
    /// alpha is a % of the fixed timestep used by update that is unused in the frame,
    /// so this must be [0.0, 1.0)
    pub fn physics_sync(&mut self, delta: f32) {
        // if this becomes a problem, then we might look at this
        // sync the state that is lerped between the previous state and the current state by alpha
        let actual_state = self.current_state.lerp(&self.previous_state, delta);
        _ = actual_state;
    }
    pub fn update(&mut self, dt: std::time::Duration, assets: &AssetCache<S>)
    where
        S: assets_manager::source::Source + Sync + 'static,
    {

    pub fn update(&mut self, dt: std::time::Duration) {

        // Reload all assets (if they have changed)
        assets.hot_reload();

        let mut view = extract_view!(self, assets);

        let mut view = extract_view!(self);

    pub fn render(&mut self, assets: &AssetCache<S>) -> Result<(), RenderError>
    where
        S: assets_manager::source::Source,
    {

    pub fn render(&mut self) -> Result<(), RenderError> {

        let (egui_output, paint_jobs) = self.gui_egui(assets);
        let text_data = TextSystemData::extract(&mut self.internal_state.world);

        let (egui_output, paint_jobs) = self.gui_egui();
        let text_data = TextSystemData::extract();

        self.text.prepare(&text_data, assets);

        self.text.prepare(&text_data);

        let camera_text_data_info: Vec<_> = self
            .text
            .produce_camera(&text_data, assets)
            .into_iter()
            .collect();

        let camera_text_data_info: Vec<_> =
            self.text.produce_camera(&text_data).into_iter().collect();

        let world_text_data_info: Vec<_> = self
            .text
            .produce_world(&text_data, assets)
            .into_iter()
            .collect();

        let world_text_data_info: Vec<_> =
            self.text.produce_world(&text_data).into_iter().collect();

//! This module handles the physics of things and how they interact
//! (and also collisions)
use std::collections::HashMap;
use ulid::Ulid;
/// The angle the physics system assumes the orthogonal view is looking at.
/// This is *not* used by the physics system for anything except
/// converting its internal position to a 2d position understandable by other systems.
// Valid angles are [0.0, pi/2).
// 0.0 means the viewer is looking straight at the ground, so z position has no effect.
// pi/2 means the view is looking *parallel* to the ground, which is not a valid angle for looking at objects
// (the orthogonal approximation only works when approximating an infinitely distant viewer, so looking at angle pi/2
// from the ground means that to see an object, its z must be at *least* infinity, which isn't possible)
pub const VIEW_ANGLE: f32 = std::f32::consts::FRAC_PI_4;
/// An entity that has been marked to be interactable by the physics system
//
// None - the corresponding internal structures have not been made to identify this object
// Some(id) - the internal structures that identify this object are stored under/with `id`
#[derive(Debug)]
pub struct PhysicalObject(Option<Ulid>);
pub struct PhysicsSystem {}
impl PhysicsSystem {
    pub fn new() -> Self {
        Self {}
    }
}
/// A description of the state of physical objects
#[derive(Debug, Clone, Default, PartialEq)]
pub struct PhysicsState {
    objects: HashMap<Ulid, PhysicsObject>,
}
impl PhysicsState {
    /// linearly interpolate between two physics states
    ///
    /// `alpha` must be [0.0, 1.0] for the math to work out
    pub fn lerp(&self, from: &Self, delta: f32) -> Self {
        let both_exist = self
            .objects
            .iter()
            .filter_map(|(id, oobj)| from.objects.get(id).map(|obj| (id, oobj, obj)));
        let only_self = self
            .objects
            .iter()
            .filter(|(id, _)| !from.objects.contains_key(*id));
        let mut new_objects = HashMap::new();
        // Lerp objects that exist in both states
        for (id, oobj, obj) in both_exist {
            new_objects.insert(*id, oobj.lerp(obj, delta));
        }
        // Copy objects that exist in only the current (self) state
        for (id, obj) in only_self {
            new_objects.insert(*id, obj.clone());
        }
        Self {
            objects: new_objects,
        }
    }
}
/// Physical description of a physics object
#[derive(Debug, Clone, PartialEq)]
pub struct PhysicsObject {
    position: glam::Vec3,
}
impl PhysicsObject {
    fn lerp(&self, from: &Self, delta: f32) -> Self {
        let position = self.position * delta + from.position * (1.0 - delta);
        Self { position }
    }
    /// Get the position
    // Maps our internal 3d position into a 2d displayable position
    fn position(&self) -> glam::Vec2 {
        // Physics is a 3d system.
        // to get the display (x, y), use
        // (x, y - z * VIEW_ANGLE.tan())
        glam::Vec2::new(
            self.position.x,
            self.position.y - VIEW_ANGLE.tan() * self.position.z,
        )
    }
}
#[cfg(test)]
mod tests;

use ulid::Ulid;
use crate::game::physics::{PhysicsObject, PhysicsState};
fn generate_physics_state(desc: impl IntoIterator<Item = (Ulid, PhysicsObject)>) -> PhysicsState {
    PhysicsState {
        objects: desc.into_iter().collect(),
    }
}
#[test]
fn lerp_0_gives_prev_state() {
    let obj_id = Ulid::new();
    let prev = generate_physics_state(vec![(
        obj_id,
        PhysicsObject {
            position: glam::Vec3::new(0.0, 0.0, 0.0),
        },
    )]);
    let current = generate_physics_state(vec![(
        obj_id,
        PhysicsObject {
            position: glam::Vec3::new(1.0, 0.0, 0.0),
        },
    )]);
    assert_eq!(prev, current.lerp(&prev, 0.0));
}
#[test]
fn lerp_1_gives_current_state() {
    let obj_id = Ulid::new();
    let prev = generate_physics_state(vec![(
        obj_id,
        PhysicsObject {
            position: glam::Vec3::new(0.0, 0.0, 0.0),
        },
    )]);
    let current = generate_physics_state(vec![(
        obj_id,
        PhysicsObject {
            position: glam::Vec3::new(1.0, 0.0, 0.0),
        },
    )]);
    assert_eq!(current, current.lerp(&prev, 1.0));
}
#[test]
fn lerp_is_linear() {
    let obj_id = Ulid::new();
    let prev = generate_physics_state(vec![(
        obj_id,
        PhysicsObject {
            position: glam::Vec3::new(0.0, 0.0, 0.0),
        },
    )]);
    let current = generate_physics_state(vec![(
        obj_id,
        PhysicsObject {
            position: glam::Vec3::new(1.0, 0.0, 0.0),
        },
    )]);
    let betwixt = generate_physics_state(vec![(
        obj_id,
        PhysicsObject {
            position: glam::Vec3::new(0.5, 0.0, 0.0),
        },
    )]);
    assert_eq!(betwixt, current.lerp(&prev, 0.5));
}
#[test]
fn lerp_copies_unique_current_objects_and_lerps_shared_objects() {
    let obj1_id = Ulid::new();
    let obj2_id = Ulid::new();
    let obj3_id = Ulid::new();
    let prev = generate_physics_state(vec![
        (
            obj1_id,
            PhysicsObject {
                position: glam::Vec3::new(0.0, 0.0, 0.0),
            },
        ),
        (
            obj2_id,
            PhysicsObject {
                position: glam::Vec3::new(1.0, 0.0, 0.0),
            },
        ),
    ]);
    let curr = generate_physics_state(vec![
        (
            obj3_id,
            PhysicsObject {
                position: glam::Vec3::new(0.0, 0.0, 0.0),
            },
        ),
        (
            obj2_id,
            PhysicsObject {
                position: glam::Vec3::new(0.0, 1.0, 1.0),
            },
        ),
    ]);
    let betwixt = generate_physics_state(vec![
        (
            obj3_id,
            PhysicsObject {
                position: glam::Vec3::new(0.0, 0.0, 0.0),
            },
        ),
        (
            obj2_id,
            PhysicsObject {
                position: glam::Vec3::new(0.5, 0.5, 0.5),
            },
        ),
    ]);
    assert_eq!(betwixt, curr.lerp(&prev, 0.5));
}

mod state;
mod object {
    use crate::game::physics::{PhysicsObject, VIEW_ANGLE};
    #[test]
    fn internal_z_maps_to_external_y() {
        let y = 12.0;
        let z = 32.0;
        let obj = PhysicsObject {
            position: glam::Vec3::new(1.0, y, z),
        };
        assert_eq!(
            obj.position(),
            glam::Vec2::new(1.0, y - z * VIEW_ANGLE.tan())
        );
    }
}

//! Scenes describe all the resources required to display the current game state.
//!
//! Only 1 scene can be active at any given moment.
use winit::event::WindowEvent;
use super::GameView;
pub trait Scene<S> {
    /// Activates the scene
    fn on_enter(&mut self, game: &mut GameView<S>);
    /// De-activates the scene
    fn on_exit(&mut self, game: &mut GameView<S>);
    /// Scene input handing, true if handled
    fn input(&mut self, event: &WindowEvent, game: &mut GameView<S>) -> bool;
    /// Updates the scene (and can return a SceneReference to go to another scene)
    fn update(&mut self, dt: std::time::Duration, game: &mut GameView<S>)
        -> Option<SceneReference>;
    /// Renders to egui's gui
    fn gui_egui(&mut self, ctx: &egui::Context, game: &mut GameView<S>);
    // Notice there's no "render" method? Yeah, the scene's responsibility is to adjust Game::world (and Game)
    // so that when the renderer comes around to rendering the world, the desired state is present to be rendered.
}
/// Scenes that can be referenced
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum SceneReference {
    /// Initial scene that starts the game
    Init,
}
/// Library of all scenes that exist
pub struct SceneLibrary;
impl SceneLibrary {
    pub fn get_scene<S>(
        &self,
        game: &mut GameView<S>,
        scene: SceneReference,
    ) -> Box<dyn Scene<S> + Send> {
        let _ = game;
        match scene {
            SceneReference::Init => Box::<MainGameScene>::default(),
        }
    }
}
#[derive(Default)]
pub struct MainGameScene {
    voop: String,
}
impl<S> Scene<S> for MainGameScene {
    fn on_enter(&mut self, game: &mut GameView<'_, S>) {
        let _ = game;
        // todo!()
    }
    fn on_exit(&mut self, game: &mut GameView<'_, S>) {
        let _ = game;
        todo!()
    }
    fn input(&mut self, event: &WindowEvent, game: &mut GameView<'_, S>) -> bool {
        let _ = game;
        let _ = event;
        false
    }
    fn update(
        &mut self,
        dt: std::time::Duration,
        game: &mut GameView<'_, S>,
    ) -> Option<SceneReference> {
        let dt_secs = dt.as_secs_f32();
        let negative = self.voop.starts_with('-');
        let negativity = if negative { -1.0 } else { 1.0 };
        if self.voop.to_lowercase().ends_with("camera") {
            if self.voop.contains("rot") {
                game.camera.transform *= glam::Affine3A::from_axis_angle(
                    glam::Vec3::Z,
                    negativity * std::f32::consts::FRAC_PI_4 * dt_secs,
                );
            } else {
                game.camera.transform.translation.x += negativity * dt_secs * 0.0025;
            }
        }
        None
    }
}
    fn gui_egui(&mut self, ctx: &egui::Context, game: &mut GameView<S>) {
        let _ = game;
        egui::Window::new("gama")
            .default_pos((10.0, 200.0))
            .show(ctx, |ui| {
                ui.label(">> Welcome to Cat Waiter <<");
                if ui
                    .text_edit_singleline(&mut self.voop)
                    .on_hover_text("the best textbox of your life")
                    .changed()
                {
                    log::info!(">> new text: {}", self.voop);
                }
            });
    }

assets_manager = { version = "0.11.2", features = ["hot-reloading", "embedded", "flac", "wav", "jpeg", "png", "ron", "json"] }

hecs = "0.10.4"

kira = { version = "0.8.7", features = ["serde"] }

serde_json = "1.0.113"

tracing = "0.1.40"
tracing-log = "0.2.0"
tracing-logfmt = "0.3.3"
tracing-subscriber = { version = "0.3.18" }

cosync = "0.2.1"

waker-fn = "1.1.1"

flume = "0.11.0"

cosync = "0.2.1"

  "tracing-subscriber/time", "instant/wasm-bindgen", "cosmic-text/wasm-web", "cosmic-text/no_std",

  "instant/wasm-bindgen", "cosmic-text/wasm-web", "cosmic-text/no_std",

desktop = ["egui-winit/default", "wgpu/default", "glyphon/default", 
  "tracing-subscriber/env-filter", "dep:pollster"]

desktop = ["egui-winit/default", "wgpu/default", "glyphon/default",  "dep:pollster"]

[[package]]
name = "alsa"
version = "0.7.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e2562ad8dcf0f789f65c6fdaad8a8a9708ed6b488e649da28c01656ad66b8b47"
dependencies = [
 "alsa-sys",
 "bitflags 1.3.2",
 "libc",
 "nix 0.24.3",
]
[[package]]
name = "alsa-sys"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "db8fee663d06c4e303404ef5f40488a53e062f89ba8bfed81f42325aafad1527"
dependencies = [
 "libc",
 "pkg-config",
]

 "jni 0.21.1",

 "jni",

 "ndk 0.8.0",

 "ndk",

 "ndk-sys 0.5.0+25.2.9519653",
 "num_enum 0.7.2",

 "ndk-sys",
 "num_enum",

name = "assets_manager"
version = "0.11.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e262912bd4b5ab66e80f5566ca5c67b39672e6ab1276533706d50bbfd15ff9d5"
dependencies = [
 "ahash",
 "assets_manager_macros",
 "crossbeam-channel",
 "image",
 "log",
 "notify",
 "rodio",
 "ron",
 "serde",
 "serde_json",
]
[[package]]
name = "assets_manager_macros"
version = "0.2.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "26f6f420eb4740134ee9a2b8da41aa4e4d281bba9e5513db122dd10853107e20"
dependencies = [
 "proc-macro2",
 "quote",
 "syn 2.0.48",
]
[[package]]

[[package]]
name = "atomic-arena"
version = "0.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5450eca8ce5abcfd5520727e975ebab30ccca96030550406b0ca718b224ead10"

name = "base64"
version = "0.21.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
[[package]]

]
[[package]]
name = "bindgen"
version = "0.69.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "a00dc851838a2120612785d195287475a3ac45514741da670b735818822129a0"
dependencies = [
 "bitflags 2.4.2",
 "cexpr",
 "clang-sys",
 "itertools",
 "lazy_static",
 "lazycell",
 "proc-macro2",
 "quote",
 "regex",
 "rustc-hash",
 "shlex",
 "syn 2.0.48",

dependencies = [
 "serde",
]

 "assets_manager",

 "flume",

 "hecs",

 "kira",

 "serde_json",

 "tracing",
 "tracing-log",
 "tracing-logfmt",
 "tracing-subscriber",

 "waker-fn",

name = "cexpr"
version = "0.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6fac387a98bb7c37292057cffc56d62ecb629900026402633ae9160df93a8766"
dependencies = [
 "nom",
]
[[package]]

name = "clang-sys"
version = "1.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "67523a3b4be3ce1989d607a828d036249522dd9c1c8de7f4dd2dae43a37369d1"
dependencies = [
 "glob",
 "libc",
 "libloading 0.8.1",
]
[[package]]
name = "claxon"
version = "0.4.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "4bfbf56724aa9eca8afa4fcfadeb479e722935bb2a0900c2d37e0cc477af0688"
[[package]]

]
[[package]]
name = "coreaudio-rs"
version = "0.11.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "321077172d79c662f64f5071a03120748d5bb652f5231570141be24cfcd2bace"
dependencies = [
 "bitflags 1.3.2",
 "core-foundation-sys",
 "coreaudio-sys",
]
[[package]]
name = "coreaudio-sys"
version = "0.2.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7f01585027057ff5f0a5bf276174ae4c1594a2c5bde93d5f46a016d76270f5a9"
dependencies = [
 "bindgen",

[[package]]
name = "cpal"
version = "0.15.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6d959d90e938c5493000514b446987c07aed46c668faaa7d34d6c7a67b1a578c"
dependencies = [
 "alsa",
 "core-foundation-sys",
 "coreaudio-rs",
 "dasp_sample",
 "jni 0.19.0",
 "js-sys",
 "libc",
 "mach2",
 "ndk 0.7.0",
 "ndk-context",
 "oboe",
 "once_cell",
 "parking_lot",
 "wasm-bindgen",
 "wasm-bindgen-futures",
 "web-sys",
 "windows 0.46.0",
]

name = "dasp_sample"
version = "0.11.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "0c87e182de0887fd5361989c677c4e8f5000cd9491d6d563161a8f3a5519fc7f"
[[package]]

[[package]]
name = "deranged"
version = "0.3.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
dependencies = [
 "powerfmt",
]

]
[[package]]
name = "encoding_rs"
version = "0.8.33"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7268b386296a025e474d5140678f75d6de9493ae55a5d709eeb9dd08149945e1"
dependencies = [
 "cfg-if",

name = "filetime"
version = "0.2.23"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1ee447700ac8aa0b2f2bd7bc4462ad686ba06baa6727ac149a2d6277f0d240fd"
dependencies = [
 "cfg-if",
 "libc",
 "redox_syscall 0.4.1",
 "windows-sys 0.52.0",
]
[[package]]

 "futures-core",
 "futures-sink",
 "nanorand",

name = "fsevent-sys"
version = "4.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "76ee7a02da4d231650c7cea31349b889be2f45ddb3ef3032d2ec8185f6313fd2"
dependencies = [
 "libc",
]
[[package]]

[[package]]
name = "glob"
version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"

 "windows 0.52.0",

 "windows",

name = "hecs"
version = "0.10.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "08c827658bc76bcffa12334eeeb575d304c5a31b71cbabd16c5f3379a9aa68c7"
dependencies = [
 "hashbrown",
 "spin",
]
[[package]]

[[package]]
name = "hound"
version = "3.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "62adaabb884c94955b19907d60019f4e145d091c75345379e70d1ee696f7854f"

]
[[package]]
name = "inotify"
version = "0.9.6"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f8069d3ec154eb856955c1c0fbffefbf5f3c40a104ec912d4797314c1801abff"
dependencies = [
 "bitflags 1.3.2",
 "inotify-sys",
 "libc",

name = "inotify-sys"
version = "0.1.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e05c02b5e89bff3b946cedeca278abc628fe811e604f027c45a8aa3cf793d0eb"
dependencies = [
 "libc",
]
[[package]]

]
[[package]]
name = "itertools"
version = "0.12.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ba291022dbbd398a455acf126c1e341954079855bc60dfdda641363bd6922569"
dependencies = [
 "either",
]
[[package]]
name = "itoa"
version = "1.0.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b1a46d1a171d865aa5f83f92695765caa047a9b4cbae2cbf37dbd613a793fd4c"
[[package]]
name = "jni"
version = "0.19.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c6df18c2e3db7e453d3c6ac5b3e9d5182664d28788126d39b91f2d1e22b017ec"
dependencies = [
 "cesu8",
 "combine",
 "jni-sys",
 "log",
 "thiserror",
 "walkdir",
]
[[package]]
name = "jni"
version = "0.20.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "039022cdf4d7b1cf548d31f60ae783138e5fd42013f6271049d7df7afadef96c"
dependencies = [
 "cesu8",
 "combine",
 "jni-sys",
 "log",
 "thiserror",
 "walkdir",

[[package]]
name = "kira"
version = "0.8.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8968f1eda49cdf4f6406fd5ffe590c3ca2778a1b0e50b5684974b138a99dfb2f"
dependencies = [
 "atomic-arena",
 "cpal",
 "glam 0.25.0",
 "mint",
 "ringbuf",
 "send_wrapper",
 "serde",
 "symphonia",
]
[[package]]
name = "kqueue"
version = "1.0.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7447f1ca1b7b563588a205fe93dea8df60fd981423a768bc1c0ded35ed147d0c"
dependencies = [
 "kqueue-sys",
 "libc",
]

name = "kqueue-sys"
version = "1.0.4"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ed9625ffda8729b85e45cf04090035ac368927b8cebc34898e7c120f52e4838b"
dependencies = [
 "bitflags 1.3.2",
 "libc",
]
[[package]]

[[package]]
name = "lazycell"
version = "1.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"

[[package]]
name = "mach2"
version = "0.4.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "19b955cdeb2a02b9117f121ce63aa52d08ade45de53e48fe6a38b39c10f6f709"
dependencies = [
 "libc",
]

name = "matchers"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8263075bb86c5a1b1427b5ae862e8889656f126e9f77c484496e8b47cf5c5558"
dependencies = [
 "regex-automata 0.1.10",
]
[[package]]

name = "minimal-lexical"
version = "0.2.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"
[[package]]

[[package]]
name = "mio"
version = "0.8.10"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "8f3d0b296e374a4e6f3c7b0a1f5a51d748a0d34c85e7dc48fc3fa9a87657fe09"
dependencies = [
 "libc",
 "log",
 "wasi",
 "windows-sys 0.48.0",
]

 "regex-syntax 0.8.2",

 "regex-syntax",

]
[[package]]
name = "nanorand"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6a51313c5820b0b02bd422f4b44776fbf47961755c74ce64afc73bfad10226c3"
dependencies = [
 "getrandom",
]
[[package]]
name = "ndk"
version = "0.7.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "451422b7e4718271c8b5b3aadf5adedba43dc76312454b387e98fae0fc951aa0"
dependencies = [
 "bitflags 1.3.2",
 "jni-sys",
 "ndk-sys 0.4.1+23.1.7779620",
 "num_enum 0.5.11",
 "raw-window-handle 0.5.2",
 "thiserror",

 "ndk-sys 0.5.0+25.2.9519653",
 "num_enum 0.7.2",

 "ndk-sys",
 "num_enum",

version = "0.4.1+23.1.7779620"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3cf2aae958bd232cac5069850591667ad422d263686d75b52a065f9badeee5a3"
dependencies = [
 "jni-sys",
]
[[package]]
name = "ndk-sys"

]
[[package]]
name = "nix"
version = "0.24.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "fa52e972a9a719cecb6864fb88568781eb706bac2cd1d4f04a648542dbf78069"
dependencies = [
 "bitflags 1.3.2",
 "cfg-if",
 "libc",

[[package]]
name = "nom"
version = "7.1.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d273983c5a657a70a3e8f2a01329822f3b8c8172b73826411a55751e404a0a4a"
dependencies = [
 "memchr",
 "minimal-lexical",
]

name = "notify"
version = "6.1.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6205bd8bb1e454ad2e27422015fb5e4f2bcc7e08fa8f27058670d208324a4d2d"
dependencies = [
 "bitflags 2.4.2",
 "crossbeam-channel",
 "filetime",
 "fsevent-sys",
 "inotify",
 "kqueue",
 "libc",
 "log",
 "mio",
 "walkdir",
 "windows-sys 0.48.0",
]
[[package]]
name = "nu-ansi-term"
version = "0.46.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "77a8165726e8236064dbb45459242600304b42a5ea24ee2948e18e023bf7ba84"
dependencies = [
 "overload",
 "winapi",
]
[[package]]
name = "num-conv"
version = "0.1.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
[[package]]
name = "num-derive"
version = "0.3.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "876a53fff98e03a936a674b29568b0e605f06b29372c2489ff4de23f1949743d"
dependencies = [
 "proc-macro2",
 "quote",
 "syn 1.0.109",
]
[[package]]

]
[[package]]
name = "num_enum"
version = "0.5.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1f646caf906c20226733ed5b1374287eb97e3c2a5c227ce668c1f2ce20ae57c9"
dependencies = [
 "num_enum_derive 0.5.11",

 "num_enum_derive 0.7.2",
]
[[package]]
name = "num_enum_derive"
version = "0.5.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "dcbff9bc912032c62bf65ef1d5aea88983b420f4f839db1e9b0c281a25c9c799"
dependencies = [
 "proc-macro-crate 1.3.1",
 "proc-macro2",
 "quote",
 "syn 1.0.109",

 "num_enum_derive",

 "proc-macro-crate 3.1.0",

 "proc-macro-crate",