Newer
Older
use std::path::PathBuf;
use tiled::{
Color, FilesystemResourceCache, FiniteTileLayer, GroupLayer, Layer, LayerType, Map,
ObjectLayer, PropertyValue, ResourceCache, TileLayer,
fn as_tile_layer<'map>(layer: Layer<'map>) -> TileLayer<'map> {
match layer.layer_type() {
LayerType::TileLayer(x) => x,
_ => panic!("Not a tile layer"),
}
}
fn as_finite<'map>(data: TileLayer<'map>) -> FiniteTileLayer<'map> {
TileLayer::Finite(data) => data,
TileLayer::Infinite(_) => panic!("Not a finite tile layer"),
}
}
fn as_object_layer<'map>(layer: Layer<'map>) -> ObjectLayer<'map> {
match layer.layer_type() {
LayerType::ObjectLayer(x) => x,
_ => panic!("Not an object layer"),
}
}
fn as_group_layer<'map>(layer: Layer<'map>) -> GroupLayer<'map> {
match layer.layer_type() {
LayerType::GroupLayer(x) => x,
_ => panic!("Not a group layer"),
}
}
fn compare_everything_but_tileset_sources(r: &Map, e: &Map) {
assert_eq!(r.version, e.version);
assert_eq!(r.orientation, e.orientation);
assert_eq!(r.width, e.width);
assert_eq!(r.height, e.height);
assert_eq!(r.tile_width, e.tile_width);
assert_eq!(r.tile_height, e.tile_height);
assert_eq!(r.properties, e.properties);
assert_eq!(r.background_color, e.background_color);
assert_eq!(r.infinite, e.infinite);
r.layers()
.zip(e.layers())
.for_each(|(r, e)| assert_eq!(r.data(), e.data()));

Doug Reeves
committed
}
#[test]
fn test_gzip_and_zlib_encoded_and_raw_are_the_same() {
let mut cache = FilesystemResourceCache::new();
let z = Map::parse_file("assets/tiled_base64_zlib.tmx", &mut cache).unwrap();
let g = Map::parse_file("assets/tiled_base64_gzip.tmx", &mut cache).unwrap();
let r = Map::parse_file("assets/tiled_base64.tmx", &mut cache).unwrap();
let zstd = Map::parse_file("assets/tiled_base64_zstandard.tmx", &mut cache).unwrap();
let c = Map::parse_file("assets/tiled_csv.tmx", &mut cache).unwrap();
compare_everything_but_tileset_sources(&z, &g);
compare_everything_but_tileset_sources(&z, &r);
compare_everything_but_tileset_sources(&z, &c);
compare_everything_but_tileset_sources(&z, &zstd);
let layer = as_finite(as_tile_layer(c.get_layer(0).unwrap()));
assert_eq!(data.width(), 100);
assert_eq!(data.height(), 100);
assert_eq!(layer.get_tile(0, 0).unwrap().id, 34);
assert_eq!(layer.get_tile(0, 1).unwrap().id, 16);
assert!(layer.get_tile(0, 2).is_none());
assert_eq!(layer.get_tile(1, 2).unwrap().id, 16);
assert!((0..99).map(|x| layer.get_tile(x, 99)).all(|t| t.is_none()));

Doug Reeves
committed
#[test]
fn test_external_tileset() {
let mut cache = FilesystemResourceCache::new();
let r = Map::parse_file("assets/tiled_base64.tmx", &mut cache).unwrap();
let e = Map::parse_file("assets/tiled_base64_external.tmx", &mut cache).unwrap();
compare_everything_but_tileset_sources(&r, &e);

Doug Reeves
committed
}
let mut cache = FilesystemResourceCache::new();
let e = Map::parse_file("assets/tiled_base64_external.tmx", &mut cache).unwrap();
e.tilesets()[0],
cache.get_tileset("assets/tilesheet.tsx").unwrap()
e.tilesets()[0].image.as_ref().unwrap().source,
#[test]
fn test_just_tileset() {
let mut cache = FilesystemResourceCache::new();
let r = Map::parse_file("assets/tiled_base64_external.tmx", &mut cache).unwrap();
assert_eq!(
r.tilesets()[0],
cache.get_tileset("assets/tilesheet.tsx").unwrap()
);
let mut cache = FilesystemResourceCache::new();
let r = Map::parse_file("assets/tiled_base64_zlib_infinite.tmx", &mut cache).unwrap();
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
if let TileLayer::Infinite(inf) = &as_tile_layer(r.get_layer(1).unwrap()) {
assert_eq!(inf.get_tile(2, 10).unwrap().id, 5);
assert_eq!(inf.get_tile(5, 36).unwrap().id, 73);
assert_eq!(inf.get_tile(15, 15).unwrap().id, 22);
} else {
assert!(false, "It is wrongly recognised as a finite map");
}
if let TileLayer::Infinite(inf) = &as_tile_layer(r.get_layer(0).unwrap()) {
// NW corner
assert_eq!(inf.get_tile(-16, 0).unwrap().id, 17);
assert!(inf.get_tile(-17, 0).is_none());
assert!(inf.get_tile(-16, -1).is_none());
// SW corner
assert_eq!(inf.get_tile(-16, 47).unwrap().id, 17);
assert!(inf.get_tile(-17, 47).is_none());
assert!(inf.get_tile(-16, 48).is_none());
// NE corner
assert_eq!(inf.get_tile(31, 0).unwrap().id, 17);
assert!(inf.get_tile(31, -1).is_none());
assert!(inf.get_tile(32, 0).is_none());
// SE corner
assert_eq!(inf.get_tile(31, 47).unwrap().id, 17);
assert!(inf.get_tile(32, 47).is_none());
assert!(inf.get_tile(31, 48).is_none());
assert!(false, "It is wrongly recognised as a finite map");
let mut cache = FilesystemResourceCache::new();
let r = Map::parse_file("assets/tiled_image_layers.tmx", &mut cache).unwrap();
assert_eq!(r.layers().len(), 2);
let mut image_layers = r.layers().map(|layer| {
if let LayerType::ImageLayer(img) = &layer.layer_type() {
(img.data(), layer.data())
} else {
panic!("Found layer that isn't an image layer")
}
});
let first = image_layers.next().unwrap();
assert_eq!(first.1.name, "Image Layer 1");
let second = image_layers.next().unwrap();
assert_eq!(second.1.name, "Image Layer 2");
.expect(&format!("{}'s image shouldn't be None", second.1.name));
assert_eq!(image.source, PathBuf::from("assets/tilesheet.png"));
assert_eq!(image.width, 448);
assert_eq!(image.height, 192);
}
}
let mut cache = FilesystemResourceCache::new();
let r = Map::parse_file("assets/tiled_base64.tmx", &mut cache).unwrap();
let prop_value: String = if let Some(&PropertyValue::StringValue(ref v)) = r.tilesets()[0]
.get_tile(1)
.unwrap()
.properties
.get("a tile property")
v.clone()
} else {
String::new()
};
assert_eq!("123", prop_value);
}
#[test]
fn test_layer_property() {
let mut cache = FilesystemResourceCache::new();
let r = Map::parse_file("assets/tiled_base64.tmx", &mut cache).unwrap();
let prop_value: String = if let Some(&PropertyValue::StringValue(ref v)) =
r.get_layer(0).unwrap().data().properties.get("prop3")
{
v.clone()
} else {
String::new()
};
assert_eq!("Line 1\r\nLine 2\r\nLine 3,\r\n etc\r\n ", prop_value);
}
#[test]
fn test_object_group_property() {
let mut cache = FilesystemResourceCache::new();
let r = Map::parse_file("assets/tiled_object_groups.tmx", &mut cache).unwrap();
let group_layer = r.get_layer(1).unwrap();
let group_layer = as_group_layer(group_layer);
let sub_layer = group_layer.get_layer(0).unwrap();
let prop_value: bool = if let Some(&PropertyValue::BoolValue(ref v)) =
sub_layer.data().properties.get("an object group property")
*v
} else {
false
};
assert!(prop_value);
}
#[test]
fn test_tileset_property() {
let mut cache = FilesystemResourceCache::new();
let r = Map::parse_file("assets/tiled_base64.tmx", &mut cache).unwrap();
let prop_value: String = if let Some(&PropertyValue::StringValue(ref v)) =
r.tilesets()[0].properties.get("tileset property")
{
v.clone()
} else {
String::new()
};
assert_eq!("tsp", prop_value);
}
fn test_flipped() {
let mut cache = FilesystemResourceCache::new();
let r = Map::parse_file("assets/tiled_flipped.tmx", &mut cache).unwrap();
let layer = as_tile_layer(r.get_layer(0).unwrap());
let t1 = layer.get_tile(0, 0).unwrap();
let t2 = layer.get_tile(1, 0).unwrap();
let t3 = layer.get_tile(0, 1).unwrap();
let t4 = layer.get_tile(1, 1).unwrap();
assert_eq!(t1.id, t2.id);
assert_eq!(t2.id, t3.id);
assert_eq!(t3.id, t4.id);
assert!(t1.flip_d);
assert!(t1.flip_h);
assert!(t1.flip_v);
assert!(!t2.flip_d);
assert!(!t2.flip_h);
assert!(t2.flip_v);
assert!(!t3.flip_d);
assert!(t3.flip_h);
assert!(!t3.flip_v);
assert!(t4.flip_d);
assert!(!t4.flip_h);
assert!(!t4.flip_v);
let mut cache = FilesystemResourceCache::new();
let r = Map::parse_file("assets/ldk_tiled_export.tmx", &mut cache).unwrap();
let layer = as_finite(as_tile_layer(r.get_layer(0).unwrap()));
assert_eq!(data.width(), 8);
assert_eq!(data.height(), 8);
assert!(layer.get_tile(0, 0).is_none());
assert_eq!(layer.get_tile(0, 1).unwrap().id, 0);
let mut cache = FilesystemResourceCache::new();
let r = Map::parse_file("assets/tiled_parallax.tmx", &mut cache).unwrap();
for (i, layer) in r.layers().enumerate() {
let data = layer.data();
assert_eq!(data.name, "Background");
assert_eq!(data.parallax_x, 0.5);
assert_eq!(data.parallax_y, 0.75);
assert_eq!(data.name, "Middle");
assert_eq!(data.parallax_x, 1.0);
assert_eq!(data.parallax_y, 1.0);
assert_eq!(data.name, "Foreground");
assert_eq!(data.parallax_x, 2.0);
assert_eq!(data.parallax_y, 2.0);
}
_ => panic!("unexpected layer"),
}
}
}
let mut cache = FilesystemResourceCache::new();
let r = Map::parse_file("assets/tiled_object_property.tmx", &mut cache).unwrap();
let layer = r.get_layer(1).unwrap();
let prop_value = if let Some(PropertyValue::ObjectValue(v)) =
as_object_layer(layer).data().objects[0]
.properties
.get("object property")
{
*v
} else {
0
};
assert_eq!(3, prop_value);
}
#[test]
fn test_tint_color() {
let mut cache = FilesystemResourceCache::new();
let r = Map::parse_file("assets/tiled_image_layers.tmx", &mut cache).unwrap();
r.get_layer(0).unwrap().data().tint_color,
Some(Color {
alpha: 0x12,
red: 0x34,
green: 0x56,
blue: 0x78
})
);
assert_eq!(
r.get_layer(1).unwrap().data().tint_color,
Some(Color {
alpha: 0xFF,
red: 0x12,
green: 0x34,
blue: 0x56
})
);
}
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
#[test]
fn test_group_layers() {
let mut cache = FilesystemResourceCache::new();
let r = Map::parse_file("assets/tiled_group_layers.tmx", &mut cache).unwrap();
// Depth = 0
let layer_tile_1 = r.get_layer(0).unwrap();
let layer_group_1 = r.get_layer(1).unwrap();
let layer_group_2 = r.get_layer(2).unwrap();
assert_eq!(
Some(&PropertyValue::StringValue("value1".to_string())),
layer_tile_1.data().properties.get("key")
);
assert_eq!(
Some(&PropertyValue::StringValue("value4".to_string())),
layer_group_1.data().properties.get("key")
);
assert_eq!(
Some(&PropertyValue::StringValue("value5".to_string())),
layer_group_2.data().properties.get("key")
);
// Depth = 1
let layer_group_1 = as_group_layer(layer_group_1);
let layer_tile_2 = layer_group_1.get_layer(0).unwrap();
let layer_group_2 = as_group_layer(layer_group_2);
let layer_group_3 = layer_group_2.get_layer(0).unwrap();
assert_eq!(
Some(&PropertyValue::StringValue("value2".to_string())),
layer_tile_2.data().properties.get("key")
);
assert_eq!(
Some(&PropertyValue::StringValue("value6".to_string())),
layer_group_3.data().properties.get("key")
);
// Depth = 2
let layer_group_3 = as_group_layer(layer_group_3);
let layer_tile_3 = layer_group_3.get_layer(0).unwrap();
assert_eq!(
Some(&PropertyValue::StringValue("value3".to_string())),
layer_tile_3.data().properties.get("key")
);
}