Changes required to compile against rs-tiled git

bjorn · Jan 24, 2022 · eb360e5 · eb360e5
1 parent 20608c0
commit eb360e5
Show file tree

Hide file tree

Showing 3 changed files with 15 additions and 17 deletions.
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -27,7 +27,7 @@ ldtk_rust = { version = "0.5" }
 rand = "0.8"
 env_logger = "0.9"
 serde_json = { version = "1.0" }
-tiled = { version = "0.9", default-features = false }
+tiled = { version = "0.9", git = "https://github.com/mapeditor/rs-tiled.git", default-features = false }
 
 [[example]]
 name = "ldtk"
@@ -42,4 +42,4 @@ name = "tiled_rotate"
 path = "examples/tiled/tiled_rotate.rs"
 
 [target.wasm32-unknown-unknown]
-runner = "wasm-server-runner"
+runner = "wasm-server-runner"
diff --git a/examples/tiled/tiled.rs b/examples/tiled/tiled.rs
@@ -20,7 +20,7 @@ impl Plugin for TiledMapPlugin {
 #[derive(TypeUuid)]
 #[uuid = "e51081d0-6168-4881-a1c6-4249b2000d7f"]
 pub struct TiledMap {
-    pub map: tiled::Map,
+    pub map: tiled::map::Map,
     pub tilesets: HashMap<u32, Handle<Image>>,
 }
 
@@ -41,14 +41,13 @@ impl AssetLoader for TiledLoader {
         load_context: &'a mut LoadContext,
     ) -> BoxedFuture<'a, Result<(), anyhow::Error>> {
         Box::pin(async move {
-            let root_dir = load_context.path().parent().unwrap();
-            let map = tiled::parse(BufReader::new(bytes))?;
+            let map = tiled::map::Map::parse_reader(BufReader::new(bytes), Some(load_context.path()))?;
 
             let mut dependencies = Vec::new();
             let mut handles = HashMap::default();
 
             for tileset in &map.tilesets {
-                let tile_path = root_dir.join(tileset.images.first().unwrap().source.as_str());
+                let tile_path = tileset.image.as_ref().unwrap().source.clone();
                 let asset_path = AssetPath::new(tile_path, None);
                 let texture: Handle<Image> = load_context.get_handle(asset_path.clone());
 
@@ -164,26 +163,26 @@ pub fn process_loaded_tile_maps(
                             ChunkSize(64, 64),
                             TileSize(tile_width, tile_height),
                             TextureSize(
-                                tileset.images[0].width as f32,
-                                tileset.images[0].height as f32,
-                            ), // TODO: support multiple tileset images?
+                                tileset.image.as_ref().unwrap().width as f32,
+                                tileset.image.as_ref().unwrap().height as f32,
+                            ),
                         );
                         map_settings.grid_size = Vec2::new(
                             tiled_map.map.tile_width as f32,
                             tiled_map.map.tile_height as f32,
                         );
 
                         map_settings.mesh_type = match tiled_map.map.orientation {
-                            tiled::Orientation::Hexagonal => {
+                            tiled::map::Orientation::Hexagonal => {
                                 TilemapMeshType::Hexagon(HexType::Row) // TODO: Support hex for real.
                             }
-                            tiled::Orientation::Isometric => {
+                            tiled::map::Orientation::Isometric => {
                                 TilemapMeshType::Isometric(IsoType::Diamond)
                             }
-                            tiled::Orientation::Staggered => {
+                            tiled::map::Orientation::Staggered => {
                                 TilemapMeshType::Isometric(IsoType::Staggered)
                             }
-                            tiled::Orientation::Orthogonal => TilemapMeshType::Square,
+                            tiled::map::Orientation::Orthogonal => TilemapMeshType::Square,
                         };
 
                         let layer_entity = LayerBuilder::<TileBundle>::new_batch(
@@ -200,15 +199,15 @@ pub fn process_loaded_tile_maps(
                                     return None;
                                 }
 
-                                if tiled_map.map.orientation == tiled::Orientation::Orthogonal {
+                                if tiled_map.map.orientation == tiled::map::Orientation::Orthogonal {
                                     tile_pos.1 = (tiled_map.map.height - 1) as u32 - tile_pos.1;
                                 }
 
                                 let x = tile_pos.0 as usize;
                                 let y = tile_pos.1 as usize;
 
                                 let map_tile = match &layer.tiles {
-                                    tiled::LayerData::Finite(tiles) => &tiles[y][x],
+                                    tiled::layers::LayerData::Finite(tiles) => &tiles[y * layer.width as usize + x],
                                     _ => panic!("Infinite maps not supported"),
                                 };