feat: use decor layer offset

battle_core/src/map/decor.rs

@@ -1,5 +1,7 @@
 use std::path::PathBuf;
 
+use crate::types::Offset;
+
 #[derive(Clone)]
 pub struct DecorTile {
     pub tileset_i: usize, // Used to rely tileset/sprite_batch in Decor
@@ -44,11 +46,16 @@ impl DecorTile {
 pub struct Decor {
     image_paths: Vec<PathBuf>,
     tiles: Vec<DecorTile>,
+    offset: Offset,
 }
 
 impl Decor {
-    pub fn new(image_paths: Vec<PathBuf>, tiles: Vec<DecorTile>) -> Self {
-        Self { image_paths, tiles }
+    pub fn new(image_paths: Vec<PathBuf>, tiles: Vec<DecorTile>, offset: Offset) -> Self {
+        Self {
+            image_paths,
+            tiles,
+            offset,
+        }
     }
 
     pub fn image_paths(&self) -> &Vec<PathBuf> {
@@ -58,4 +65,8 @@ impl Decor {
     pub fn tiles(&self) -> &Vec<DecorTile> {
         &self.tiles
     }
+
+    pub fn offset(&self) -> Offset {
+        self.offset
+    }
 }

battle_core/src/map/reader.rs

@@ -12,7 +12,10 @@ use tiled::{
     TileLayer, Tileset,
 };
 
-use crate::game::flag::{Flag, FlagName};
+use crate::{
+    game::flag::{Flag, FlagName},
+    types::Offset,
+};
 
 use super::{
     decor::{Decor, DecorTile},
@@ -296,10 +299,11 @@ impl MapReader {
         }
     }
 
-    fn decor_layer(&self) -> Result<FiniteTileLayer, MapReaderError> {
-        match self.layer(DECOR_LAYER_NAME)?.layer_type() {
+    fn decor_layer(&self) -> Result<(Layer, FiniteTileLayer), MapReaderError> {
+        let decor_layer = self.layer(DECOR_LAYER_NAME)?;
+        match decor_layer.layer_type() {
             LayerType::TileLayer(layer) => match layer{
-                TileLayer::Finite(layer) => Ok(layer),
+                TileLayer::Finite(layer_) => Ok((decor_layer, layer_)),
                 TileLayer::Infinite(_) => Result::Err(MapReaderError::InvalidLayer(format!(
                     "Layer '{}' in map {} is an infinite tile layer, but on finite layer is supported",
                     DECOR_LAYER_NAME, self.name,
@@ -433,14 +437,14 @@ impl MapReader {
     }
 
     fn decor_tilesets(&self) -> Result<DecorTilesets, MapReaderError> {
-        let layer = self.decor_layer()?;
+        let (_, layer_) = self.decor_layer()?;
         let mut tileset_indexes = vec![];
         let mut tilesets = vec![];
         let mut positions = HashMap::new();
 
-        for x in 0..layer.width() {
-            for y in 0..layer.height() {
-                if let Some(layer_tile_data) = layer.get_tile_data(x as i32, y as i32) {
+        for x in 0..layer_.width() {
+            for y in 0..layer_.height() {
+                if let Some(layer_tile_data) = layer_.get_tile_data(x as i32, y as i32) {
                     if !tileset_indexes.contains(&layer_tile_data.tileset_index()) {
                         tileset_indexes.push(layer_tile_data.tileset_index());
                     }
@@ -478,7 +482,7 @@ impl MapReader {
     }
 
     fn decor(&self) -> Result<Decor, MapReaderError> {
-        let decor_layer = self.decor_layer()?;
+        let (decor_layer, decor_layer_) = self.decor_layer()?;
         let (_, tilesets_positions) = self.decor_tilesets()?;
         let images = self.decor_images()?;
         let image_paths = images
@@ -497,9 +501,9 @@ impl MapReader {
 
         let mut tiles = vec![];
 
-        for x in 0..decor_layer.width() {
-            for y in 0..decor_layer.height() {
-                if let Some(layer_tile_data) = decor_layer.get_tile_data(x as i32, y as i32) {
+        for x in 0..decor_layer_.width() {
+            for y in 0..decor_layer_.height() {
+                if let Some(layer_tile_data) = decor_layer_.get_tile_data(x as i32, y as i32) {
                     let tileset = self.map.tilesets()[layer_tile_data.tileset_index()].clone();
 
                     let decor_tileset_position = *tilesets_positions
@@ -529,12 +533,13 @@ impl MapReader {
                         tile_y,
                     );
 
-                    tiles.push(terrain_tile)
+                    tiles.push(terrain_tile);
                 };
             }
         }
 
-        Ok(Decor::new(image_paths, tiles))
+        let offset = Offset::new(-decor_layer.offset_x, -decor_layer.offset_y);
+        Ok(Decor::new(image_paths, tiles, offset))
     }
 
     pub fn build(&self) -> Result<Map, MapReaderError> {

battle_core/src/types.rs

@@ -458,6 +458,10 @@ impl Offset {
         Self { x, y }
     }
 
+    pub fn zero() -> Self {
+        Self { x: 0., y: 0. }
+    }
+
     pub fn half() -> Self {
         Self { x: 0.5, y: 0.5 }
     }

battle_gui/src/graphics/decors.rs

@@ -1,7 +1,7 @@
 use battle_core::{
     game::control::MapControl,
     map::Map,
-    types::{ScenePoint, WorldPoint},
+    types::{Offset, ScenePoint, WorldPoint},
 };
 use ggez::{
     graphics::{DrawParam, Image, InstanceArray, Rect},
@@ -15,11 +15,16 @@ use super::{batch::QualifiedBatch, qualified::Zoom};
 pub struct Decors {
     sd: Vec<InstanceArray>,
     hd: Vec<InstanceArray>,
+    offset: Offset,
 }
 
 impl Decors {
-    pub fn new(sd: Vec<InstanceArray>, hd: Vec<InstanceArray>) -> Self {
-        Self { sd, hd }
+    pub fn new(sd: Vec<InstanceArray>, hd: Vec<InstanceArray>, offset: Offset) -> Self {
+        Self { sd, hd, offset }
+    }
+
+    pub fn offset(&self) -> Offset {
+        self.offset
     }
 }
 
@@ -80,6 +85,7 @@ impl<'a> DecorsBuilder<'a> {
         Ok(Decors::new(
             self.build_for(&Zoom::default())?,
             self.build_for(&Zoom::hd())?,
+            self.map.decor().offset(),
         ))
     }
 

battle_gui/src/graphics/mod.rs

@@ -476,6 +476,7 @@ impl Graphics {
         zoom: &Zoom,
     ) -> GameResult {
         if draw_decor {
+            let draw_param = draw_param.offset(self.decor.offset().to_vec2() * zoom.factor());
             self.decor
                 .drawable(zoom)
                 .iter()