diff --git a/dt_lib/src/battle/army.rs b/dt_lib/src/battle/army.rs
index a3eaf6e..8c953fa 100644
--- a/dt_lib/src/battle/army.rs
+++ b/dt_lib/src/battle/army.rs
@@ -19,7 +19,7 @@ use num::{integer::sqrt, pow};
 use once_cell::sync::Lazy;
 use pathfinding::directed::astar::astar;
 
-use super::control::Control;
+use super::control::{Control, PC_ControlSetings};
 #[derive(Clone, Debug, Default, Sections)]
 #[alkahest(Deserialize, Serialize, SerializeRef, Formula)]
 pub struct ArmyStats {
@@ -70,6 +70,7 @@ pub struct Army {
     pub defeated: bool,
     //#[default_value = "Control::PC"]
     pub control: Control,
+	pub pc_settings: Option<PC_ControlSetings>,
     //#[unused]
     pub path: Vec<(usize, usize)>,
 }
@@ -101,6 +102,7 @@ impl Army {
     ) -> Self {
         let hitmap: Vec<Option<usize>> = (0..*MAX_TROOPS).map(|_| None::<usize>).collect();
         let mut army = Army {
+			pc_settings: None,
             troops: Vec::new(),
             building: None,
             hitmap,
@@ -221,8 +223,8 @@ impl Army {
         Ok(())
     }
 
-    pub fn add_item(&mut self, item: usize) {
-        self.inventory.push(Item { index: item })
+    pub fn add_item(&mut self, item: Item) {
+        self.inventory.push(item)
     }
     pub fn remove_item(&mut self, rem_item: usize) {
         if let Some(index) = self
@@ -304,14 +306,14 @@ pub fn find_path(
             }
             .into_iter()
             .filter(|p: &(usize, usize)| {
-                let hitbox = &gamemap.hitmap[p.0][p.1];
+                let hitbox = &gamemap.hitmap[*p];
                 hitbox.passable()
                     && (!(hitbox.need_transport ^ on_transport)
                         || hitbox.building.is_some_and(|n| {
                             objects[gamemap.buildings[n].id].obj_type == ObjectType::Bridge
                         }))
             })
-            .map(|p| (p, 10 / TILES[gamemap.tilemap[p.0][p.1]].walkspeed))
+            .map(|p| (p, 10 / TILES[gamemap.tilemap[p]].walkspeed))
         },
         |&p| dist(&p, &goal),
         |&p| p == goal,
diff --git a/dt_lib/src/battle/control.rs b/dt_lib/src/battle/control.rs
index 28a1161..683c9db 100644
--- a/dt_lib/src/battle/control.rs
+++ b/dt_lib/src/battle/control.rs
@@ -1,12 +1,15 @@
 use advini::{Ini, IniParseError};
 use alkahest::*;
+use math_thingies::Percent;
+
+use crate::time::time::Time;
 #[derive(Clone, Debug)]
 #[alkahest(Deserialize, Serialize, SerializeRef, Formula)]
 pub struct Relations {
-    player: u8,
-    ally: u8,
-    neighbour: u8,
-    enemy: u8,
+    pub player: u8,
+    pub ally: u8,
+    pub neighbour: u8,
+    pub enemy: u8,
 }
 impl Ini for Relations {
     fn eat(chars: std::str::Chars) -> Result<(Self, std::str::Chars), IniParseError> {
@@ -73,17 +76,27 @@ impl Ini for Control {
 }
 
 #[derive(Clone, Debug, Default)]
+#[alkahest(Deserialize, Serialize, SerializeRef, Formula)]
 pub struct PC_ControlSetings {
-    xp_like_player: bool,
-    xp_add: u64,
-    units_dont_have_money: bool,
-    ignores_ai_armys: bool,
-    targets_player: bool,
-    forbid_random_targets: bool,
-    forbid_random_talks: bool,
-    not_interested_in_buildings: bool,
-    patrol_radius: Option<u64>,
-    relations: Relations,
+    pub xp_like_player: bool,
+    pub xp_add: u64,
+	pub xp_correction: Percent,
+	pub gold_income: u64,
+	pub mana_income: u64,
+	pub speed_correction: Percent,
+    pub units_dont_have_money: bool,
+    pub ignores_ai_armys: bool,
+    pub targets_player: bool,
+    pub forbid_random_targets: bool,
+    pub forbid_random_talks: bool,
+    pub not_interested_in_buildings: bool,
+	pub aggression: u8,
+	pub patrol: u8,
+	pub revive_everyone: bool,
+	pub revive_time: Time,
+	pub garrison_power: u8,
+    pub patrol_radius: Option<u64>,
+    pub relations: Relations,
 }
 #[derive(Clone, Debug)]
 pub enum Target {
diff --git a/dt_lib/src/lib.rs b/dt_lib/src/lib.rs
index cbc6855..1c54355 100644
--- a/dt_lib/src/lib.rs
+++ b/dt_lib/src/lib.rs
@@ -1,3 +1,4 @@
+#![allow(unused_imports)]
 pub mod battle;
 pub mod bonuses;
 pub mod effects;
diff --git a/dt_lib/src/map/convert.rs b/dt_lib/src/map/convert.rs
index eb0ebbc..53a96b4 100644
--- a/dt_lib/src/map/convert.rs
+++ b/dt_lib/src/map/convert.rs
@@ -1,10 +1,14 @@
-use super::{deco::*, map::*};
+use crate::{
+    battle::{control::{Control, Relations}, Army, ArmyStats, Troop}, items::{Item, ITEMS}, map::object::{BuildingVariant, Village}, mutrc::SendMut, time::time::Time, units::unit::{Unit, UNITS}
+};
+
+use super::{deco::*, map::*, object::{MapBuildingdata, Market, RecruitUnit, Recruitment}};
 use bufread::BzDecoder;
 use bytes::*;
 use bzip2::*;
+use core::str;
 use encoding_rs::*;
 use num_enum::{Default, FromPrimitive, IntoPrimitive};
-use core::str;
 use std::{
     fs,
     fs::File,
@@ -55,7 +59,7 @@ pub struct ManyUnitsData {
 }
 #[derive(FromBytes, Unaligned, Debug, Copy, Clone, PartialEq, Eq)]
 #[repr(packed(1))]
-pub struct RecruitUnit {
+pub struct RecruitUnitData {
     pub id: u8,
     pub amount: u8,
     pub max_amount: u8,
@@ -240,7 +244,7 @@ pub struct BuildingData {
     pub event_ids: [u16; 64],              // айди событий в максимальном количестве 64 штуки 136
     pub artifact_ids: [u16; 6],            // на рынке 5 штук, в руинах 4 максимально 148
     pub _empty_big: [u8; 117],             //
-    pub recruits: [RecruitUnit; 6],        // найм в казармах 282
+    pub recruits: [RecruitUnitData; 6],        // найм в казармах 282
     pub gold_income: u16,                  // золотой доход 284
     pub max_gold_income: u16,              // максимальный золотой доход? 286
     pub _empty: [u8; 2],                   // 288
@@ -256,13 +260,13 @@ pub struct BuildingData {
     pub spell_ids: [u8; 5], // айди заклинаний 314 bytes (info about spells available for study)
     pub garrison_units: [GarrisonUnit; 6], // гарнизон 332 bytes
     pub additional_garrison_defense: u8, // дополнительная защита гарнизона 333
-    pub min_artifact_price: u16, // минимальная стоимость артефактов 335,
-    pub max_artifact_price: u16, // максимальная стоимость артефактов 337,
+    pub min_artifact_price: u16, // минимальная стоимость артефактов на продажу 335,
+    pub max_artifact_price: u16, // максимальная стоимость артефактов на продажу 337,
     pub group: u8,         // союзник, сосед, враг в таком духе 338
     pub relations: RelationsData, // отношения здания 342
     pub _empty4: [u8; 8],  // 350
     pub mana_income: u8,   // приток маны 351
-    pub max_mana_income: u8, // максимальный приток маны 352
+    pub max_mana_income: u8, // максимальный приток маны в деревне 352
     pub _empty5: [u8; 1],  // 353
     pub knight_start_building: u8, // стартовое здание рыцаря 354
     pub mage_start_building: u8, // стартовое здание архимага 355
@@ -344,7 +348,7 @@ pub struct LightOrEvent {
     pub map_model: u8,
     pub _empty: [u8; 33],
     pub light_radius: u8,
-	pub _empty1: [u8; 59]
+    pub _empty1: [u8; 59],
 }
 #[derive(FromBytes, Unaligned, PartialEq, Eq, Debug, Copy, Clone)]
 #[repr(packed(1))]
@@ -359,9 +363,9 @@ pub struct MapData {
     pub map: Vec<u8>,
     pub decos: Vec<Decoration>,
     pub armies: Vec<ArmyData>,
-	pub lanterns: Vec<LightOrEvent>,
-	pub events: Vec<EventData>,
-	pub text: Vec<String>
+    pub lanterns: Vec<LightOrEvent>,
+    pub events: Vec<EventData>,
+    pub text: Vec<String>,
 }
 pub fn parse_dtm_map(path: &Path) -> Result<MapData, ()> {
     let mut buf: bytes::Bytes = {
@@ -370,6 +374,9 @@ pub fn parse_dtm_map(path: &Path) -> Result<MapData, ()> {
         file.read_to_end(&mut buf);
         Bytes::copy_from_slice(&buf)
     };
+    parse_dtm_map_by_bytes(buf)
+}
+pub fn parse_dtm_map_by_bytes(mut buf: Bytes) -> Result<MapData, ()> {
     let mut header_buf_start = buf.copy_to_bytes(8);
     buf.advance(4);
     let bzip_buf = buf.copy_to_bytes(4);
@@ -449,78 +456,308 @@ pub fn parse_dtm_map(path: &Path) -> Result<MapData, ()> {
         parse_vec_by_bytes(bytes)
     }
     fn parse_text(bytes: &mut Bytes) -> Vec<String> {
-		fn copy_until(bytes: &mut Bytes, amount: usize, until: &[u8]) -> Vec<u8> {
-			let mut buf = vec![];
-			loop {
-				if bytes.is_empty() {
-					break buf;
-				}
-				let copy = bytes.copy_to_bytes(amount);
-				if copy.as_bytes() == until {
-					break buf;
-				} else {
-					buf.extend_from_slice(copy.as_bytes());
-				}
-			}
-		}
-		const TEXT_SECTION_START: [u8; 8] = *b"\x00>-Text-";
-		let section = bytes.copy_to_bytes(TEXT_SECTION_START.len());
-		if section.as_bytes() != TEXT_SECTION_START {
-			println!("Wrong text section start {:?} {:?}", section.as_bytes(), str::from_utf8(section.as_bytes()));
-		}
+        fn copy_until(bytes: &mut Bytes, amount: usize, until: &[u8]) -> Vec<u8> {
+            let mut buf = vec![];
+            loop {
+                if bytes.is_empty() {
+                    break buf;
+                }
+                let copy = bytes.copy_to_bytes(amount);
+                if copy.as_bytes() == until {
+                    break buf;
+                } else {
+                    buf.extend_from_slice(copy.as_bytes());
+                }
+            }
+        }
+        const TEXT_SECTION_START: [u8; 8] = *b"\x00>-Text-";
+        let section = bytes.copy_to_bytes(TEXT_SECTION_START.len());
+        if section.as_bytes() != TEXT_SECTION_START {
+            println!(
+                "Wrong text section start {:?} {:?}",
+                section.as_bytes(),
+                str::from_utf8(section.as_bytes())
+            );
+        }
         let mut text_buffer = vec![];
         loop {
-			let buf = copy_until(bytes, 1, &[0]);
-			let string = if buf.is_empty() {
-				String::new()
-			} else { WINDOWS_1251.decode(&buf).0.to_string() };
-			if string.contains("LIT") || bytes.is_empty() {
-				break;
-			}
-			text_buffer.push(string);
-		}
+            let buf = copy_until(bytes, 1, &[0]);
+            let string = if buf.is_empty() {
+                String::new()
+            } else {
+                WINDOWS_1251.decode(&buf).0.to_string()
+            };
+            if string.contains("LIT") || bytes.is_empty() {
+                break;
+            }
+            text_buffer.push(string);
+        }
         text_buffer
     }
-    let mut map = parse_by_2_bytes(surface_data);
+    let map = parse_by_2_bytes(surface_data);
     let decos = parse_decos(objects_data);
     let armies = parse_armies(armies_data);
     let buildings = parse_buildings(buildings_data);
     let lanterns = parse_lanterns(lanterns_data);
     let events = parse_events(events_data);
     let text = parse_text(&mut texts_data);
+    // Дальше идет лит картинка и хрен с ней
+
     Ok(MapData {
         settings,
         buildings,
         decos,
         map,
-		events,
-		lanterns,
+        events,
+        lanterns,
         armies,
-		text,
+        text,
     })
 }
+pub fn parse_dtm_texts(
+    data: &mut MapData,
+) -> (
+    (String, String),
+    (String, String),
+    Vec<(String, String, String)>,
+    Vec<(String, String, String)>,
+    Vec<(String, String, String)>,
+) {
+	let texts = &mut data.text;
+    let name = texts.remove(0);
+    let desc = texts.remove(0);
+
+    let comp = texts.remove(0);
+    let next = texts.remove(0);
+
+    let mut buildings = vec![];
+    for _ in &data.buildings {
+        let name = texts.remove(0);
+        let owner = texts.remove(0);
+        let desc = texts.remove(0);
+        buildings.push((name, owner, desc));
+    }
+    let mut armies = vec![];
+    for _ in &data.armies {
+        let name = texts.remove(0);
+        let warlord = texts.remove(0);
+        let desc = texts.remove(0);
+        armies.push((name, warlord, desc));
+    }
+
+    let mut events = vec![];
+    for _ in &data.events {
+        let name = texts.remove(0);
+        let question = texts.remove(0);
+        let text = texts.remove(0);
+        events.push((name, question, text));
+    }
+
+    // TODO: Named units handling
+
+    dbg!(((name, desc), (comp, next), buildings, armies, events))
+}
+trait FromDtm {
+	type From;
+	type Additional;
+	type Texts;
+	fn from_dtm(from: &Self::From, texts: &mut Self::Texts, additional: Self::Additional) -> Self;
+}
+impl FromDtm for Relations {
+	type Additional = ();
+	type From = RelationsData;
+	type Texts = ();
+	fn from_dtm(from: &Self::From, _: &mut Self::Texts, _: Self::Additional) -> Self {
+		Self {
+			player: from.a,
+			ally: from.b,
+			neighbour: from.c,
+			enemy: from.d
+		}
+	}
+}
+impl FromDtm for Army {
+	type Additional = usize;
+	type From = ArmyData;
+	type Texts = Vec<(String, String, String)>;
+
+	fn from_dtm(army: &Self::From, armies_texts: &mut Self::Texts, id: Self::Additional) -> Self {
+		let mut troops = vec![];
+		let units = UNITS.read().unwrap();
+		let (army_name, _, _) = armies_texts.remove(0);
+		for troop in &army.troops.troops {
+			troops.extend([
+				&units[troop.id.min(100) as usize]
+			].iter().cycle().take(troop.amount as usize));
+		}
+		let troops = troops.iter().map(|x: &&Unit| {
+			SendMut::new(Troop::new(<Unit as Clone>::clone(x)))
+		});
+		let stats = ArmyStats {
+			gold: 0,
+			mana: 0,
+			army_name
+		};
+		let inventory = army.items_ids.map(|index| Item { index: index as usize }).to_vec();
+		let pos = pos_from_dtm((army.x as usize, army.y as usize));
+		let active = army.activity.to_bool();
+		let control = Control::PC;
+		Army::new(troops.collect(),
+				  stats,
+				  inventory,
+				  pos,
+				  active,
+				  control)
+	}
+}
+impl FromDtm for MapBuildingdata {
+	type Additional = usize;
+	type From = BuildingData;
+	type Texts = Vec<(String, String, String)>;
+
+	fn from_dtm(building: &Self::From, building_texts: &mut Self::Texts, id: Self::Additional) -> Self {
+		let pos = pos_from_dtm((building.x as usize, building.y as usize));
+		let size = pos_from_dtm((building.size_x as usize, building.size_y as usize));
+		let events = building.event_ids.map(|x| x as usize).to_vec();
+		let gold_income = building.gold_income as u64;
+		let mana_income = building.mana_income as u64;
+		let (name, desc, owner_name) = building_texts.remove(0);
+		let spells_to_learn = building.spell_ids.map(|x| x as usize).to_vec();
+		let group = building.group as usize;
+		let owner = match building.owner_army_id as usize {
+			255 => None,
+			x => Some(x)
+		};
+		let additional_defense = building.additional_garrison_defense as u64;
+		let (items, max_items) = (
+			building.artifact_ids.map(|x| Item {index: x as usize }).to_vec(),
+			building.number_of_artifacts_for_sale as usize,
+		);
+		let (max_mana, max_gold) = (
+			building.max_mana_income as u64,
+			building.max_gold_income as u64,
+		);
+		let variant = match building.variant {
+			1 => BuildingVariant::Town,
+			2 => BuildingVariant::Village(Village { max_mana, max_gold }),
+			3 => BuildingVariant::Castle,
+			4 => BuildingVariant::Fort,
+			5 => BuildingVariant::Tavern,
+			6 => BuildingVariant::Market,
+			7 => BuildingVariant::Church,
+			8 => BuildingVariant::Forge,
+			9 => BuildingVariant::Verf,
+			10 => BuildingVariant::Altar,
+			11 => BuildingVariant::Mine,
+			12 => BuildingVariant::Ruins(items.clone()),
+			13 => BuildingVariant::StoneBridge,
+			14 => BuildingVariant::WoodenBridge,
+			_ => BuildingVariant::Ruins(items.clone()),
+		};
+		let itemcost_range = (building.min_artifact_price as u64, building.max_artifact_price as u64);
+		let market = if matches!(variant, BuildingVariant::Market | BuildingVariant::Town | BuildingVariant::Church) && max_items != 0 {
+			Market {
+				itemcost_range,
+				items,
+				max_items
+			}.into()
+		} else { None };
+		let recruitment = Some(Recruitment::new(building.recruits.map(|x| RecruitUnit { unit: x.id as usize, count: x.amount as usize}).to_vec(), 1.));
+		let mut garrison = vec![];
+		for unit in building.garrison_units {
+			let units = [UNITS.read().unwrap()[unit.id.min(100) as usize].clone()];
+			let units = units
+				.iter()
+				.cycle()
+				.take(unit.count as usize)
+				.map(|x| x.clone())
+				.collect::<Vec<_>>();
+			garrison.extend(units);
+		}
+		MapBuildingdata {
+			owner_name,
+			additional_defense,
+			name,
+			desc,
+			id,
+			events,
+			variant,
+			gold_income,
+			mana_income,
+			garrison,
+			group,
+			market,
+			recruitment,
+			owner,
+			pos,
+			spells_to_learn,
+			relations: Relations::from_dtm(&building.relations, &mut (), ()),
+		}
+	}
+}
+pub fn pos_from_dtm(pos: (usize, usize)) -> (usize, usize) {
+	(pos.1, pos.0)
+}
+pub fn convert_dtm_map(mut data: MapData) -> GameMap {
+	let ((name, description), (company_name, next_map), mut buildings_text, mut armies_text, mut events_text) = parse_dtm_texts(&mut data);
+    let mut tilemap = TileMap::new(data.map.iter().map(|x| *x as usize));
+	for y in 0..(data.settings.size_y as usize) {
+		for x in 0..(data.settings.size_x as usize) {
+			tilemap[pos_from_dtm((x, y))] = data.map[x * tilemap.size + y] as usize;
+		}
+	}
+	let decomap: Vec<usize> = data.decos.iter().map(|x| x.id as usize).collect();
+    let time = data.settings.start_time;
+	let seed = data.settings.seed as usize;
+	let winning_event_id = data.settings.winning_event_id as usize;
+	let losing_event_id = data.settings.losing_event_id as usize;
+	let scenario = match data.settings.scenario_variant {
+		0 => ScenarioVariant::Single,
+		1 => ScenarioVariant::Start(next_map),
+		_ => ScenarioVariant::Series(next_map),
+	};
+	let size = (data.settings.size_x, data.settings.size_y);
+	let buildings = data.buildings.iter().enumerate().map(|(id, b)| MapBuildingdata::from_dtm(&b, &mut buildings_text, id)).collect();
+	let armys = data.armies.iter().enumerate().map(|(id, a)| Army::from_dtm(&a, &mut armies_text, id)).collect();
+	GameMap {
+		pause: false,
+		start: StartStats {
+			name,
+			description,
+			seed,
+			winning_event_id,
+			losing_event_id,
+			scenario,
+			time: Time::new(time as u64)
+		},
+		time: Time::new(time as u64),
+		tilemap,
+		decomap,
+		relations: FractionsRelations::default(),
+		hitmap: TileMap::new((0..(size.0 * size.0)).map(|_| HitboxTile::default())),
+		buildings,
+		armys
+	}
+}
 mod test {
     use std::{
         fs::{self, File},
-        io::Write,
+        io::{Read, Write},
         os,
         path::Path,
     };
 
+    use bytes::Bytes;
+
     #[test]
     fn test() {
-        for path in fs::read_dir("../dt/Maps_Rus/").unwrap() {
-            let path = path.as_ref().unwrap();
-            if !path.file_name().to_str().unwrap().ends_with("DTm") {
-                continue;
-            }
-            let data = super::parse_dtm_map(&path.path().as_path()).unwrap();
-            let map = data.map;
-            let (map_height, map_width) =
-                (data.settings.size_x as usize, data.settings.size_y as usize);
-            let terr_ascii = [
-                "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F",
-            ];
-        }
+        let buf = include_bytes!("../../../dt/Maps_Rus/РК1-Начало пути.DTm");
+        let data = super::parse_dtm_map_by_bytes(Bytes::copy_from_slice(buf)).unwrap();
+        let map = data.map;
+        let (map_height, map_width) =
+            (data.settings.size_x as usize, data.settings.size_y as usize);
+        let terr_ascii = [
+            "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C", "D", "E", "F",
+        ];
     }
 }
diff --git a/dt_lib/src/map/event.rs b/dt_lib/src/map/event.rs
index 721ba6a..860b1d5 100644
--- a/dt_lib/src/map/event.rs
+++ b/dt_lib/src/map/event.rs
@@ -1,9 +1,5 @@
 use crate::{
-    battle::troop::Troop,
-    map::map::GameMap,
-    mutrc::SendMut,
-    time::time::Time,
-    units::unit::{Unit, UnitPos},
+    battle::troop::Troop, items::Item, map::map::GameMap, mutrc::SendMut, time::time::Time, units::unit::{Unit, UnitPos}
 };
 use advini::{Ini, IniParseError, Section, SectionError, Sections, SEPARATOR};
 use serde;
@@ -197,42 +193,6 @@ pub struct Conditions {
     #[default_value = "None"]
     pub in_building: Option<usize>,
 }
-impl Conditions {
-    fn new(
-        relative_time: bool,
-        repeat: Option<Time>,
-        activation_time: Time,
-        if_event_executed: Option<usize>,
-        armys_defeated: Option<Vec<usize>>,
-        not_executed: Option<Vec<usize>>,
-        flag_check: String,
-        xp_req: Option<Cmp<u64>>,
-        gold_req: Option<Cmp<u64>>,
-        mana_req: Option<Cmp<u64>>,
-        army_req: Option<Cmp<u64>>,
-        power_req: Option<Cmp<u64>>,
-        hero_has_1_hp: bool,
-        in_building: Option<usize>,
-    ) -> Self {
-        Self {
-            relative_time,
-            executed: false,
-            repeat,
-            activation_time,
-            if_event_executed,
-            army_req,
-            not_executed,
-            flag_check,
-            xp_req,
-            gold_req,
-            mana_req,
-            armys_defeated,
-            hero_has_1_hp,
-            power_req,
-            in_building,
-        }
-    }
-}
 #[derive(
     Clone, Debug, Default, Sections, serde::Serialize, serde::Deserialize, FieldNamesAsArray,
 )]
@@ -266,42 +226,7 @@ pub struct EventResult {
     #[default_value = "None"]
     pub remove_units: Option<Vec<usize>>,
     #[default_value = "None"]
-    pub change_personality: Option<usize>,
-}
-impl EventResult {
-    fn new(
-        lit_lights: Option<Vec<usize>>,
-        delay: (Time, bool),
-        flag_change: String,
-        sub_event: Option<Vec<usize>>,
-        delayed_event: Option<DelayedEvent>,
-        minus_items: Option<Vec<usize>>,
-        plus_items: Option<Vec<usize>>,
-        question: Option<(String, Vec<String>)>,
-        change_xp: i64,
-        change_gold: i64,
-        change_mana: i64,
-        add_units: Option<Vec<usize>>,
-        remove_units: Option<Vec<usize>>,
-        change_personality: Option<usize>,
-    ) -> Self {
-        Self {
-            lit_lights,
-            delay,
-            flag_change,
-            sub_event,
-            delayed_event,
-            minus_items,
-            plus_items,
-            question,
-            change_gold,
-            change_mana,
-            change_personality,
-            change_xp,
-            add_units,
-            remove_units,
-        }
-    }
+    pub change_personality: Option<usize>, // Changes player-controlled army
 }
 
 #[derive(Clone, Debug, Default, Sections, serde::Serialize, serde::Deserialize)]
@@ -486,7 +411,7 @@ pub fn execute_event_as_player(
         if let Some(add_items) = &mut result.plus_items {
             add_items
                 .iter()
-                .for_each(|item| gamemap.armys[player].add_item(*item));
+                .for_each(|item| gamemap.armys[player].add_item(Item { index: *item }));
         }
 
         {
diff --git a/dt_lib/src/map/map.rs b/dt_lib/src/map/map.rs
index 7103cab..567e772 100644
--- a/dt_lib/src/map/map.rs
+++ b/dt_lib/src/map/map.rs
@@ -1,3 +1,5 @@
+use std::ops::{Index, IndexMut};
+
 use super::{
     object::{MapBuildingdata, ObjectInfo},
     tile::*,
@@ -8,12 +10,53 @@ use crate::{
 };
 use advini::{Ini, IniParseError, Section, SectionError, Sections};
 use alkahest::alkahest;
+use num::integer::Roots;
 
 pub type Tilemap<T> = [[T; MAP_SIZE]; MAP_SIZE];
+#[derive(Clone, Debug, Default)]
+#[alkahest(Deserialize, Serialize, SerializeRef, Formula)]
+pub struct TileMap<T> {
+    pub inner: Vec<T>,
+	pub size: usize,
+}
+impl<T> TileMap<T> {
+	pub fn new(iter: impl Iterator<Item=T>) -> Self {
+		let inner = iter.collect::<Vec<_>>();
+		let len = inner.len();
+		Self {
+			inner,
+			size: len.sqrt() as usize
+		}
+	}
+}
+impl<T> AsMut<TileMap<T>> for TileMap<T> {
+	fn as_mut(&mut self) -> &mut TileMap<T> {
+		self
+	}
+}
+impl<T> IntoIterator for TileMap<T> {
+	type IntoIter = <Vec<T> as IntoIterator>::IntoIter;
+	type Item = T;
+	fn into_iter(self) -> Self::IntoIter {
+		self.inner.into_iter()
+	}
+}
+impl<T> Index<(usize, usize)> for TileMap<T> {
+	type Output = T;
+	fn index(&self, index: (usize, usize)) -> &Self::Output {
+&self.inner[index.1 + index.0 * self.size]
+	}
+}
+impl<T> IndexMut<(usize, usize)> for TileMap<T> {
+	fn index_mut(&mut self, index: (usize, usize)) -> &mut Self::Output {
+&mut self.inner[index.1 + index.0 * self.size]
+	}
+}
 #[derive(Copy, Clone, Debug)]
 #[alkahest(Deserialize, Serialize, SerializeRef, Formula)]
 pub struct HitboxTile {
     pub passable: bool,
+	pub deco_blocked: bool,
     pub need_transport: bool,
     pub building: Option<usize>,
     pub army: Option<usize>,
@@ -26,6 +69,7 @@ impl HitboxTile {
 impl Default for HitboxTile {
     fn default() -> Self {
         HitboxTile {
+			deco_blocked: false,
             passable: true,
             need_transport: false,
             building: None,
@@ -55,20 +99,46 @@ impl FractionsRelations {
 }
 pub const MAP_SIZE: usize = 50;
 
+#[derive(Clone, Debug, Default, advini::Ini)]
+#[alkahest(Deserialize, Serialize, SerializeRef, Formula)]
+pub enum ScenarioVariant {
+    #[default]
+    Single,
+    Start(String),
+    Series(String),
+}
+#[derive(Clone, Debug, Default, Sections)]
+#[alkahest(Deserialize, Serialize, SerializeRef, Formula)]
+pub struct NextMapSettings {
+    #[default_value = "true"]
+    pub save_mana: bool,
+    #[default_value = "true"]
+    pub save_gold: bool,
+    #[default_value = "true"]
+    pub save_xp_and_lvl: bool,
+    #[default_value = "true"]
+    pub save_own_items: bool,
+    #[default_value = "true"]
+    pub save_all_items: bool,
+    #[default_value = "true"]
+    pub save_all_troops: bool,
+}
 #[derive(Clone, Debug, Default, Sections)]
 #[alkahest(Deserialize, Serialize, SerializeRef, Formula)]
 pub struct StartStats {
+    #[default_value = "\"New map\""]
+    pub name: String,
+    #[default_value = "String::new()"]
+    pub description: String,
+    #[unused]
+    #[default_value = "0usize"]
+    pub seed: usize,
+    pub winning_event_id: usize,
+    pub losing_event_id: usize,
+    #[default_value = "ScenarioVariant::Single"]
+    pub scenario: ScenarioVariant,
     #[alias([start_time])]
     pub time: Time,
-    #[alias([start_money])]
-    pub money: u64,
-    #[alias([start_mana])]
-    pub mana: u64,
-}
-impl StartStats {
-    pub fn new(time: Time, money: u64, mana: u64) -> Self {
-        Self { time, money, mana }
-    }
 }
 #[derive(Clone, Debug, Sections)]
 #[alkahest(Deserialize, Serialize, SerializeRef, Formula)]
@@ -78,11 +148,11 @@ pub struct GameMap {
     #[unused]
     pub time: Time,
     #[unused]
-    pub tilemap: Tilemap<usize>,
+    pub tilemap: TileMap<usize>,
     #[unused]
-    pub decomap: Tilemap<Option<usize>>,
+    pub decomap: Vec<usize>,
     #[unused]
-    pub hitmap: Tilemap<HitboxTile>,
+    pub hitmap: TileMap<HitboxTile>,
     #[unused]
     pub buildings: Vec<MapBuildingdata>,
     #[unused]
@@ -97,9 +167,9 @@ impl Default for GameMap {
         GameMap {
             start: Default::default(),
             time: Default::default(),
-            tilemap: [[0; MAP_SIZE]; MAP_SIZE],
-            decomap: [[None; MAP_SIZE]; MAP_SIZE],
-            hitmap: [[HitboxTile::default(); MAP_SIZE]; MAP_SIZE],
+            tilemap: Default::default(),
+            decomap: vec![],
+            hitmap: Default::default(),
             buildings: Vec::new(),
             armys: Vec::new(),
             relations: Default::default(),
@@ -118,41 +188,33 @@ impl GameMap {
         }
     }
     pub fn calc_hitboxes(&mut self, objects: &[ObjectInfo]) {
-        for ((tileline, decoline), x) in self
-            .tilemap
-            .iter()
-            .zip(self.decomap.iter())
-            .zip(0..MAP_SIZE)
-        {
-            for ((tile, deco), y) in tileline.iter().zip(decoline.iter()).zip(0..MAP_SIZE) {
-                let hitbox = &mut self.hitmap[x][y];
-                hitbox.need_transport = TILES[*tile].need_transport();
-            }
-        }
+		for (i, _) in &mut self.tilemap.inner.iter().enumerate() {
+            self.hitmap.inner[i].need_transport = TILES[self.tilemap.inner[i]].need_transport();
+		}
         self.recalc_armies_hitboxes();
         for (i, building) in self.buildings.iter().enumerate() {
             let size = objects[building.id].size;
             for x in 0..size.0 {
                 for y in 0..size.1 {
                     let hitbox =
-                        &mut self.hitmap[building.pos.0 + x as usize][building.pos.1 + y as usize];
+                        &mut self.hitmap[(building.pos.0 + x as usize, building.pos.1 + y as usize)];
                     hitbox.building = Some(i);
+					hitbox.passable = TILES[self.tilemap[(building.pos.0 + x as usize, building.pos.1 + y as usize)]].walkspeed != 0;
                 }
             }
         }
     }
+	pub fn recalc_deco_hitboxes(&mut self) {
+	}
     pub fn recalc_armies_hitboxes(&mut self) {
-        self.hitmap.iter_mut().for_each(|arr| {
-            arr.iter_mut().for_each(|el| {
-                el.army = None;
-            })
-        });
+		for hit in self.hitmap.inner.iter_mut() {
+			hit.army = None;
+		}
         for (i, army) in self.armys.iter().enumerate() {
             if !army.active || army.defeated {
                 continue;
             }
-            let (x, y) = army.pos;
-            self.hitmap[x][y].army = Some(i);
+            self.hitmap[army.pos].building = Some(i);
         }
     }
 }
diff --git a/dt_lib/src/map/object.rs b/dt_lib/src/map/object.rs
index c754c5d..8024138 100644
--- a/dt_lib/src/map/object.rs
+++ b/dt_lib/src/map/object.rs
@@ -2,11 +2,12 @@ use std::collections::HashMap;
 
 use crate::{
     battle::{army::Army, control::Relations, troop::Troop},
-    items::item::ITEMS,
+    items::{item::ITEMS, Item},
     units::unit::Unit,
 };
 use advini::*;
 use alkahest::alkahest;
+use num_enum::FromPrimitive;
 use rand::{seq::SliceRandom, thread_rng};
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
@@ -45,11 +46,21 @@ impl Ini for Village {
 #[derive(Clone, Debug, Ini)]
 #[alkahest(Deserialize, Serialize, SerializeRef, Formula)]
 pub enum BuildingVariant {
+    Town,
     Village(Village),
     Castle,
-    Ruined,
+    Fort,
+    Tavern,
+    Market,
+    Church,
+    Forge,
+    Verf,
+    Altar,
+    Mine,
+    Ruins(Vec<Item>),
+    StoneBridge,
+    WoodenBridge,
 }
-
 #[derive(Clone, Debug, Sections)]
 #[alkahest(Deserialize, Serialize, SerializeRef, Formula)]
 pub struct MapBuildingdata {
@@ -57,6 +68,8 @@ pub struct MapBuildingdata {
     #[alias([description])]
     #[default_value = "String::new()"]
     pub desc: String,
+	#[default_value = "String::new()"]
+	pub owner_name: String,
 
     pub id: usize,
 
@@ -90,55 +103,16 @@ pub struct MapBuildingdata {
     #[default_value = "0usize"]
     pub group: usize,
 }
-impl MapBuildingdata {
-    pub fn new(
-        name: String,
-        desc: String,
-        id: usize,
-        events: Vec<usize>,
-        variant: BuildingVariant,
-        market: Option<Market>,
-        recruitment: Option<Recruitment>,
-        pos: (usize, usize),
-        owner: Option<usize>,
-        garrison: Vec<Unit>,
-        additional_defense: u64,
-        gold_income: u64,
-        mana_income: u64,
-        spells_to_learn: Vec<usize>,
-        relations: Relations,
-        group: usize,
-    ) -> Self {
-        Self {
-            name,
-            desc,
-            id,
-            events,
-            variant,
-            market,
-            recruitment,
-            pos,
-            owner,
-            garrison,
-            additional_defense,
-            gold_income,
-            mana_income,
-            spells_to_learn,
-            relations,
-            group,
-        }
-    }
-}
 const RECRUIT_COST: f64 = 2.0;
 #[derive(Clone, Debug, Sections)]
 #[alkahest(Deserialize, Serialize, SerializeRef, Formula)]
 pub struct Market {
     pub itemcost_range: (u64, u64),
-    pub items: Vec<usize>,
+    pub items: Vec<Item>,
     pub max_items: usize,
 }
 impl Market {
-    fn new(itemcost_range: (u64, u64), items: Vec<usize>, max_items: usize) -> Self {
+    fn new(itemcost_range: (u64, u64), items: Vec<Item>, max_items: usize) -> Self {
         Self {
             itemcost_range,
             items,
@@ -157,7 +131,7 @@ impl Market {
             self.items.append(
                 &mut nice_items
                     .choose_multiple(&mut thread_rng(), self.max_items)
-                    .map(|(index, _)| **index)
+                    .map(|(index, _)| Item { index: **index })
                     .collect(),
             );
         }
@@ -172,22 +146,14 @@ impl Market {
         }
     }
     fn can_buy(&self, buyer: &Army, item_num: usize) -> bool {
-        if ITEMS.lock().unwrap()[self
-            .items
-            .get(item_num)
-            .expect("Trying to get item at unknown place")]
-        .sells
+        if self.items[item_num].get_info().sells
         {
             return buyer.stats.gold >= self.get_item_cost(item_num);
         }
         false
     }
     fn get_item_cost(&self, item_num: usize) -> u64 {
-        ITEMS.lock().unwrap()[self
-            .items
-            .get(item_num)
-            .expect("Trying to get item at unknown place")]
-        .cost
+        self.items[item_num].get_info().cost
     }
 }
 #[derive(Clone, Debug)]
diff --git a/dt_lib/src/map/tile.rs b/dt_lib/src/map/tile.rs
index 228dd0f..3dc9eab 100644
--- a/dt_lib/src/map/tile.rs
+++ b/dt_lib/src/map/tile.rs
@@ -20,20 +20,21 @@ impl Tile {
     }
 }
 
-pub static TILES: [Tile; 15] = [
+pub static TILES: [Tile; 16] = [
     Tile::new(4, "Shallow.png", true),
     Tile::new(4, "Water.png", true),
-    Tile::new(0, "DeepWater.png", false),
-    Tile::new(0, "FlameLand.png", false),
+    Tile::new(10, "DeepWater.png", false),
+    Tile::new(10, "FlameLand.png", false),
     Tile::new(4, "Road.png", false),
     Tile::new(2, "LowLand.png", false),
     Tile::new(2, "Land.png", false),
     Tile::new(2, "Plain.png", false),
     Tile::new(1, "Swamp.png", false),
-    Tile::new(0, "DeepSwamp.png", false),
+    Tile::new(10, "DeepSwamp.png", false),
     Tile::new(2, "Desert.png", false),
     Tile::new(1, "Badground.png", false),
     Tile::new(1, "Rock.png", false),
     Tile::new(1, "Dust.png", false),
     Tile::new(2, "Snow.png", false),
+	Tile::new(2, "Snow.png", false),
 ];
diff --git a/dt_lib/src/network/net.rs b/dt_lib/src/network/net.rs
index 6378388..b90670e 100644
--- a/dt_lib/src/network/net.rs
+++ b/dt_lib/src/network/net.rs
@@ -211,7 +211,7 @@ impl GameServer {
                 let army_index = client_id
                     .and_then(|v| self.auth.get(&v).cloned())
                     .unwrap_or(0usize);
-                if let Some(target_army) = gamemap.hitmap[goal.0][goal.1].army {
+                if let Some(target_army) = gamemap.hitmap[goal].army {
                     let Some(army) = gamemap.armys.get(army_index) else {
                         return;
                     };
@@ -340,7 +340,7 @@ impl GameServer {
                             else {
                                 continue;
                             };
-                            if let Some(target_army) = gamemap.hitmap[goal.0][goal.1].army {
+                            if let Some(target_army) = gamemap.hitmap[goal].army {
                                 let Some(army) = gamemap.armys.get(army_index) else {
                                     continue;
                                 };
@@ -408,7 +408,7 @@ impl GameServer {
                 }
                 moved = true;
                 army.pos = army.path.remove(0);
-                if let Some(building) = gamemap.hitmap[army.pos.0][army.pos.1].building {
+                if let Some(building) = gamemap.hitmap[army.pos].building {
                     army.building = Some(building);
                 } else {
                     army.building = None;
diff --git a/dt_lib/src/parse.rs b/dt_lib/src/parse.rs
index 3ad2fdb..4c5bf91 100644
--- a/dt_lib/src/parse.rs
+++ b/dt_lib/src/parse.rs
@@ -112,7 +112,7 @@ d-Vampirizm=[{отсутствие строки}/1-100] — +вампиризм
 
  */
 use math_thingies::add_opt;
-use num::Num;
+use num::{integer::Roots, Num};
 
 use super::{
     battle::{control::Control, troop::Troop},
@@ -137,10 +137,10 @@ use crate::{
         control::Relations,
     },
     items,
-    map::object::BuildingVariant,
+    map::{map::TileMap, object::BuildingVariant},
 };
 use advini::*;
-use ini_core::{Item, Parser};
+use ini_core::{Item as IniItem, Parser};
 use math_thingies::Percent;
 use once_cell::sync::Lazy;
 use std::{
@@ -600,12 +600,12 @@ fn parse_for_props(path: &str) -> HashMap<String, String> {
     let parser = Parser::new(&*ini_doc).auto_trim(true);
     for item in parser {
         match item {
-            Item::Section(_) => {}
-            Item::Property(k, v) => {
+            IniItem::Section(_) => {}
+            IniItem::Property(k, v) => {
                 props.insert(k.to_lowercase().into(), v.into());
             }
-            Item::Blank | Item::Action(_) | Item::Comment(_) => {}
-            Item::Error(err) => panic!("{}", err),
+            IniItem::Blank | IniItem::Action(_) | IniItem::Comment(_) => {}
+            IniItem::Error(err) => panic!("{}", err),
         }
     }
     props
@@ -987,13 +987,13 @@ fn parse_mapdata(
     locale: &mut Locale,
     objects: &Objects,
 ) -> (
-    Tilemap<usize>,
-    Tilemap<Option<usize>>,
+    TileMap<usize>,
+	Vec<usize>,
     Vec<MapBuildingdata>,
     Vec<Army>,
 ) {
-    let mut tilemap: Option<Tilemap<usize>> = None;
-    let mut decomap: Option<Tilemap<Option<usize>>> = None;
+    let mut tilemap: Option<TileMap<usize>> = None;
+    let mut decomap: Vec<usize> = vec![];
 
     let mut armys = Vec::new();
     let mut buildings = Vec::new();
@@ -1005,45 +1005,17 @@ fn parse_mapdata(
                     match &*prop.0 {
                         "tilemap" => {
                             tilemap = Some({
-                                let mut tiles = prop
+                                let tilemap = prop
                                     .1
                                     .split(|ch: char| !ch.is_ascii_digit())
                                     .map(|ch| ch.parse::<usize>().unwrap());
-                                (0..MAP_SIZE)
-                                    .map(|_| {
-                                        (0..MAP_SIZE)
-                                            .map(|_| tiles.next().unwrap())
-                                            .collect::<Vec<_>>()
-                                            .try_into()
-                                            .unwrap()
-                                    })
-                                    .collect::<Vec<_>>()
-                                    .try_into()
-                                    .unwrap()
-                            })
+								TileMap::new(tilemap)
+                            });
                         }
                         "decomap" => {
-                            decomap = Some({
-                                let (tiles, _) = <Vec<usize> as Ini>::eat(prop.1.chars()).unwrap();
-                                // prop.1.split(|ch: char| !ch.is_ascii_digit())
-                                // 	.map(|ch|
-                                // 		 if ch=="0" {
-                                // 			 None
-                                // 		 } else { Some(ch.parse().unwrap()) }
-                                // 	);
-                                (0..MAP_SIZE)
-                                    .map(|_| {
-                                        (0..MAP_SIZE)
-                                            .zip(tiles.iter())
-                                            .map(|(_, v)| if *v == 0 { None } else { Some(*v) })
-                                            .collect::<Vec<_>>()
-                                            .try_into()
-                                            .unwrap()
-                                    })
-                                    .collect::<Vec<_>>()
-                                    .try_into()
-                                    .unwrap()
-                            })
+                            decomap = {
+                                Vec::<usize>::eat(prop.1.chars()).unwrap().0
+                            }
                         }
                         _ => {}
                     }
@@ -1151,7 +1123,7 @@ fn parse_mapdata(
                         "id" => id = Some(prop.1.parse().unwrap()),
                         "type" => building_type = Some(prop.1),
                         "owner" => owner = Some(prop.1.parse().unwrap()),
-                        "items" => items = split_and_parse(prop.1),
+                        "items" => items = split_and_parse::<usize>(prop.1).iter().map(|index| Item { index: *index }).collect(),
                         "defense" => defense = prop.1.parse().ok(),
                         "object" => object_name = prop.1.into(),
                         "itemcost_range" => {
@@ -1205,6 +1177,7 @@ fn parse_mapdata(
                 buildings.push((
                     id.unwrap(),
                     MapBuildingdata {
+						owner_name: String::new(),
                         spells_to_learn: Vec::new(),
                         variant: BuildingVariant::Castle,
                         garrison: Vec::new(),
@@ -1232,7 +1205,7 @@ fn parse_mapdata(
     }
     (
         tilemap.unwrap(),
-        decomap.unwrap(),
+        decomap,
         {
             buildings.sort_by(|(id, _), (oth_id, _)| id.cmp(oth_id));
             buildings
diff --git a/dt_lib/src/units/unit.rs b/dt_lib/src/units/unit.rs
index 0e80ccd..6836e5b 100644
--- a/dt_lib/src/units/unit.rs
+++ b/dt_lib/src/units/unit.rs
@@ -626,78 +626,74 @@ impl Unit {
             target.being_attacked(&damage, self, target_pos, my_pos, battle);
             Some(ActionResult::Melee)
         } else {
-            match self.info.magic_type {
-                None => None,
-                Some(magic_type) => {
-                    let direction = get_magic_direction(magic_type);
-                    match (direction, magic_type, is_enemy) {
-                        (ToAlly, _, false) => match magic_type {
-                            Death(_) | Life(_) => heal_bless(self, target, damage, magic_type),
-                            Elemental(_) => elemental_bless(self, target, damage),
-                        },
-                        (ToAll, _, _) => match (magic_type, is_enemy) {
-                            (Death(_) | Life(_), true) => {
-                                if is_in_back {
-                                    magic_attack(
-                                        self, target, damage, magic_type, my_pos, target_pos,
-                                        battle,
-                                    )
-                                } else {
-                                    None
-                                }
-                            }
-                            (Death(_) | Life(_), false) => {
-                                heal_bless(self, target, damage, magic_type)
-                            }
-                            (Elemental(_), true) => {
-                                if is_in_back {
-                                    elemental_attack(
-                                        self, target, damage, target_pos, my_pos, battle,
-                                    )
-                                } else {
-                                    None
-                                }
-                            }
-                            (Elemental(_), false) => elemental_bless(self, target, damage),
-                        },
-                        (ToEnemy, _, true) => {
-                            if is_in_back {
-                                match magic_type {
-                                    Death(_) | Life(_) => magic_attack(
-                                        self, target, damage, magic_type, my_pos, target_pos,
-                                        battle,
-                                    ),
-                                    Elemental(_) => elemental_attack(
-                                        self, target, damage, target_pos, my_pos, battle,
-                                    ),
-                                }
-                            } else {
-                                None
-                            }
+			let Some(magic_type) = self.info.magic_type else { return None; };
+            let direction = get_magic_direction(magic_type);
+            match (direction, magic_type, is_enemy) {
+                (ToAlly, _, false) => match magic_type {
+                    Death(_) | Life(_) => heal_bless(self, target, damage, magic_type),
+                    Elemental(_) => elemental_bless(self, target, damage),
+                },
+                (ToAll, _, _) => match (magic_type, is_enemy) {
+                    (Death(_) | Life(_), true) => {
+                        if is_in_back {
+                            magic_attack(
+                                self, target, damage, magic_type, my_pos, target_pos,
+                                battle,
+                            )
+                        } else {
+                            None
                         }
-                        (CurseOnly, _, true) => match magic_type {
-                            Death(_) | Life(_) => magic_curse(self, target, damage, magic_type),
-                            Elemental(_) => elemental_curse(self, target, damage),
-                        },
-                        (StrikeOnly, _, true) => {
-                            damage.hand = 0;
-                            damage.ranged = 0;
-                            target.being_attacked(&damage, self, my_pos, target_pos, battle);
-                            Some(ActionResult::Debuff)
+                    }
+                    (Death(_) | Life(_), false) => {
+                        heal_bless(self, target, damage, magic_type)
+                    }
+                    (Elemental(_), true) => {
+                        if is_in_back {
+                            elemental_attack(
+                                self, target, damage, target_pos, my_pos, battle,
+                            )
+                        } else {
+                            None
                         }
-                        (BlessOnly, _, false) => match magic_type {
-                            Life(_) | Death(_) => bless_unit(self, target, damage, magic_type),
-                            Elemental(_) => elemental_bless(self, target, damage),
-                        },
-                        (CureOnly, Life(_) | Death(_), false) => {
-                            heal_unit(self, target, damage, magic_type)
+                    }
+                    (Elemental(_), false) => elemental_bless(self, target, damage),
+                },
+                (ToEnemy, _, true) => {
+                    if is_in_back {
+                        match magic_type {
+                            Death(_) | Life(_) => magic_attack(
+                                self, target, damage, magic_type, my_pos, target_pos,
+                                battle,
+                            ),
+                            Elemental(_) => elemental_attack(
+                                self, target, damage, target_pos, my_pos, battle,
+                            ),
                         }
-                        _ => None,
+                    } else {
+                        None
                     }
                 }
+                (CurseOnly, _, true) => match magic_type {
+                    Death(_) | Life(_) => magic_curse(self, target, damage, magic_type),
+                    Elemental(_) => elemental_curse(self, target, damage),
+                },
+                (StrikeOnly, _, true) => {
+                    damage.hand = 0;
+                    damage.ranged = 0;
+                    target.being_attacked(&damage, self, my_pos, target_pos, battle);
+                    Some(ActionResult::Debuff)
+                }
+                (BlessOnly, _, false) => match magic_type {
+                    Life(_) | Death(_) => bless_unit(self, target, damage, magic_type),
+                    Elemental(_) => elemental_bless(self, target, damage),
+                },
+                (CureOnly, Life(_) | Death(_), false) => {
+                    heal_unit(self, target, damage, magic_type)
+                }
+                _ => None,
             }
-        };
-    }
+        }
+	}
 
     pub fn heal(&mut self, amount: u64) -> bool {
         let effected = self.modified;
diff --git a/dtm_info/src/main.rs b/dtm_info/src/main.rs
index ad14efd..9f07527 100644
--- a/dtm_info/src/main.rs
+++ b/dtm_info/src/main.rs
@@ -2,7 +2,8 @@ use std::path::{Path, PathBuf};
 
 use clap::*;
 use dt_lib::map::convert::{
-    parse_dtm_map, ArmyTroopsData, BuildingData, EventData, GarrisonUnit, HeroInfoData, PatrolData, ToBool
+    parse_dtm_map, ArmyTroopsData, BuildingData, EventData, GarrisonUnit, HeroInfoData, PatrolData,
+    ToBool,
 };
 use zerocopy::FromZeros;
 #[derive(Parser)]
@@ -16,12 +17,12 @@ struct Args {
     /// To show buildings info
     #[arg(short, default_value_t = false)]
     buildings: bool,
-	/// To show texts
-	#[arg(short, default_value_t = false)]
-	texts: bool,
-	/// To show events
-	#[arg(short, default_value_t = false)]
-	events: bool,
+    /// To show texts
+    #[arg(short, default_value_t = false)]
+    texts: bool,
+    /// To show events
+    #[arg(short, default_value_t = false)]
+    events: bool,
     /// To show map
     #[arg(short, default_value_t = false)]
     map: bool,
@@ -343,14 +344,14 @@ fn main() {
         if_not_zero(empty6, |empty6| println!("Empty6/ is: {:?}", empty6));
         if_not_zero(empty7, |empty7| println!("Empty7/ is: {:?}", empty7));
     }
-	if args.events {
-		dbg!(data.events);
-	}
-	if args.texts {
-		for text in data.text {
-			if !text.is_empty() {
-				print!("{} | ", text);
-			}
-		}
-	}
+    if args.events {
+        dbg!(data.events);
+    }
+    if args.texts {
+        for text in data.text {
+            if !text.is_empty() {
+                print!("{} | ", text);
+            }
+        }
+    }
 }
diff --git a/quad_ui/src/main.rs b/quad_ui/src/main.rs
index 8653206..93a5fc5 100644
--- a/quad_ui/src/main.rs
+++ b/quad_ui/src/main.rs
@@ -204,7 +204,7 @@ fn draw_map(assets: &Assets, camera: &mut Camera2D, game: &mut Game) {
     set_camera(camera);
     for i in 0..MAP_SIZE {
         for j in 0..MAP_SIZE {
-            let tile = TILES[gamemap.tilemap[i][j]];
+            let tile = TILES[gamemap.tilemap[(i, j)]];
             draw_texture(
                 assets.get(&tile.sprite().to_string()),
                 i as f32 * SIZE.0,
diff --git a/ui/src/main.rs b/ui/src/main.rs
index c584e0e..2530eda 100644
--- a/ui/src/main.rs
+++ b/ui/src/main.rs
@@ -8,10 +8,7 @@ use dt_lib::{
     items::item::*,
     locale::{parse_locale, Locale},
     map::{
-        event::{execute_event, Event as GameEvent, Execute},
-        map::*,
-        object::ObjectInfo,
-        tile::*,
+        convert::{convert_dtm_map, parse_dtm_map}, event::{execute_event, Event as GameEvent, Execute}, map::*, object::ObjectInfo, tile::*
     },
     network::net::*,
     parse::{parse_items, parse_objects, parse_settings, parse_story, parse_units},
@@ -195,7 +192,7 @@ static FORMS: Lazy<Mutex<HashMap<usize, SingleContainer<State, DynContainer<Stat
 static LOCALE: Lazy<Mutex<Locale>> =
     Lazy::new(|| Mutex::new(Locale::new("Rus".into(), "Eng".into())));
 static MONITOR_SIZE: Lazy<Mutex<(f32, f32)>> = Lazy::new(|| Mutex::new((0., 0.)));
-
+const SIZE: (f32, f32) = (12., 10.);
 #[repr(u32)]
 enum Menu {
     Main,
@@ -653,6 +650,7 @@ fn gen_forms(size: (f32, f32)) -> Result<(), String> {
                                         .position(|obj| obj.path == "Tree0.png")
                                         .unwrap(),
                                 );
+								 let decomap = vec![];
                                 state.gamemap.tilemap = tilemap.0;
                                 state.gamemap.decomap = decomap;
                                 let (objects, gamemap) = (&state.objects, &mut state.gamemap);
@@ -842,10 +840,10 @@ fn gen_forms(size: (f32, f32)) -> Result<(), String> {
 								let clicked_at = app.mouse.position();
 								let start = state.gamemap.armys[0].pos;
 								let goal = (
-									(clicked_at.0 / SIZE.0) as usize,
-									(clicked_at.1 / SIZE.1) as usize,
+									(clicked_at.0 / SIZE.0) as usize - state.gamemap.armys[0].pos.0,
+									(clicked_at.1 / SIZE.1) as usize - state.gamemap.armys[0].pos.1,
 								);
-								if let Some(army) = state.gamemap.hitmap[goal.0][goal.1].army  {
+								if let Some(army) = state.gamemap.hitmap[goal].army  {
 									if army != 0 {
 										let pos = state.gamemap.armys[0].pos;
 										let diff = (pos.0 as i64 - goal.0 as i64, pos.1 as i64 - goal.1 as i64);
@@ -869,7 +867,7 @@ fn gen_forms(size: (f32, f32)) -> Result<(), String> {
 							}
 							// grand gameloopa
 							let mut pause = false;
-							for i in 0..=1 {
+							for i in 0..1 {
 								let army = &mut state.gamemap.armys[i];
 								if army.path.len() < 1 {
 									if i == 0 {
@@ -886,7 +884,7 @@ fn gen_forms(size: (f32, f32)) -> Result<(), String> {
 										continue;
 									}
 									army.pos = army.path.remove(0);
-									if let Some(building) = state.gamemap.hitmap[army.pos.0][army.pos.1].building {
+									if let Some(building) = state.gamemap.hitmap[army.pos].building {
 										army.building = Some(building);
 									} else { army.building = None; }
 									state.gamemap.recalc_armies_hitboxes();
@@ -1215,7 +1213,7 @@ fn gen_forms(size: (f32, f32)) -> Result<(), String> {
         .build()
     }
 
-    const SIZE: (f32, f32) = (52., 40.);
+
     const VIEW: usize = 20;
     fn draw_gamemap<Form: PosForm<State>>(
         drawing: &mut Form,
@@ -1227,20 +1225,32 @@ fn gen_forms(size: (f32, f32)) -> Result<(), String> {
         draw: &mut Draw,
     ) {
         let terrain = assets.get("assets/Terrain").unwrap();
-        let army = assets.get("assets/Armys").unwrap();
-        draw.image(
-            &assets
-                .get("assets/Map")
-                .and_then(|map| map.get("Map"))
-                .unwrap()
-                .lock()
-                .unwrap(),
-        )
-        .position(0., 0.);
+        let army_pic = assets.get("assets/Armys").unwrap();
+        //draw.image(
+        //     &assets
+        //         .get("assets/Map")
+        //         .and_then(|map| map.get("Map"))
+        //         .unwrap()
+        //         .lock()
+        //         .unwrap(),
+        // )
+	 	//.position(0., 0.);
+		//.size(52., 42.);
+		
+		let terrain = assets.get("assets/Terrain").unwrap();
+		for i in 0..(gamemap.tilemap.size) {
+			for j in 0..(gamemap.tilemap.size) {
+				let pos = Position(i as f32 * SIZE.0, j as f32 * SIZE.1);
+				let asset = terrain.get(TILES[gamemap.tilemap[(i, j)]].sprite()).unwrap();
+				draw.image(&*asset.lock().unwrap())
+					.position(pos.0, pos.1)
+					.size(SIZE.0, SIZE.1);
+			}
+		}
         let pos = gamemap.armys[0].pos;
-        for i in 0..MAP_SIZE {
+        for i in 0..(gamemap.tilemap.size) {
             //((pos.0 - VIEW / 2).clamp(0, MAP_SIZE))..((pos.0 + VIEW/2).clamp(0, MAP_SIZE)) {
-            for j in 0..MAP_SIZE {
+            for j in 0..(gamemap.tilemap.size) {
                 //((pos.0 - VIEW / 2).clamp(0, MAP_SIZE))..((pos.0 + VIEW/2).clamp(0, MAP_SIZE)) {
                 // let asset = terrain
                 //     .get(TILES[state.gamemap.tilemap[i][j]].sprite())
@@ -1254,29 +1264,34 @@ fn gen_forms(size: (f32, f32)) -> Result<(), String> {
                 if gamemap.armys[0].path.contains(&(i, j)) {
                     draw.rect((pos).into(), (10., 10.)).color(Color::RED);
                 }
-                if gamemap.armys[1].path.contains(&(i, j)) {
-                    draw.rect((pos).into(), (10., 10.)).color(Color::BLUE);
-                }
-                if gamemap.hitmap[i][j].army.is_some() {
-                    let pos: (f32, f32) = (pos - Position(0., SIZE.1)).into();
-                    draw.image(&army.get("Army.png").unwrap().lock().unwrap())
+                // if gamemap.armys[1g].path.contains(&(i, j)) {
+                //     draw.rect((pos).into(), (10., 10.)).color(Color::BLUE);
+                // }
+                if gamemap.hitmap[(i, j)].army.is_some() {
+                    draw.image(&army_pic.get("Army.png").unwrap().lock().unwrap())
                         .position(pos.0, pos.1)
                         .size(SIZE.0, SIZE.1 * 2.);
                 }
             }
         }
+		for army in &gamemap.armys {
+			let pos = Position(army.pos.0 as f32 * SIZE.0, army.pos.1 as f32 * SIZE.1);
+			draw.image(&army_pic.get("Army.png").unwrap().lock().unwrap())
+                        .position(pos.0, pos.1)
+                        .size(SIZE.0, SIZE.1 * 2.);
+		}
         for i in 0..0 {
             //i in ((pos.0 - VIEW / 2).clamp(0, MAP_SIZE))..((pos.0 + VIEW/2).clamp(0, MAP_SIZE)) {
             for j in 0..0 {
                 //j in ((pos.0 - VIEW / 2).clamp(0, MAP_SIZE))..((pos.0 + VIEW/2).clamp(0, MAP_SIZE)) {
-                let asset = terrain.get(TILES[gamemap.tilemap[i][j]].sprite()).unwrap();
+                let asset = terrain.get(TILES[gamemap.tilemap[(i, j)]].sprite()).unwrap();
                 let texture = asset.lock().unwrap();
                 const ALPHA: f32 = 0.2;
                 const W_SIZE_QUARTER: f32 = SIZE.0 / 4.;
                 const H_SIZE_QUARTER: f32 = SIZE.1 / 4.;
                 const QUARTER_TILE: f32 = 106. / 4.;
                 const THREE_QUARTERS: f32 = QUARTER_TILE * 3.;
-                let pos = Position(i as f32 * SIZE.0, j as f32 * SIZE.1);
+                let pos = Position((i + gamemap.armys[0].pos.0) as f32 * SIZE.0, (j + gamemap.armys[0].pos.1) as f32 * SIZE.1);
                 (0..4).for_each(|i| {
                     let (quarter_size, crop_start, cropped_size, quarter_pos) = match i {
                         0 => (
@@ -1317,7 +1332,7 @@ fn gen_forms(size: (f32, f32)) -> Result<(), String> {
                 .expect(&*format!("{}", &objects[index].path));
             let texture = asset.lock().unwrap();
             let size = objects[index].size;
-            let pos = Position(i as f32 * SIZE.0, j as f32 * SIZE.1);
+            let pos = Position((i + gamemap.armys[0].pos.0) as f32 * SIZE.0, (j + gamemap.armys[0].pos.1) as f32 * SIZE.1);
             draw.image(&texture)
                 .position(pos.0, pos.1) // - (size.1 as f32 - 1.) * SIZE.1)
                 .size(SIZE.0 * size.0 as f32, SIZE.1 * size.1 as f32);
@@ -1440,12 +1455,12 @@ fn gen_forms(size: (f32, f32)) -> Result<(), String> {
 					if let Some(market) = &building.market {
 					vec![Box::new(container(
 							market.items.iter().enumerate().map(|(n, itemn)| {
-								let item = &items[itemn];
+								let item = &items[&itemn.index];
 								button(single(TupleContainerBuilder::default()
 									.inside((
 										TextureRenderer {
 											rect: Rect { pos: Position(0., 0.), size: Size(30., 30.) },
-											texture_id: ("assets/Items".into(), format!("img_{}.png", itemn)),
+											texture_id: ("assets/Items".into(), format!("img_{}.png", itemn.index)),
 											to_draw: |cont,_,_,_,_, state: &mut State, draw| {
 												draw.image(&state.get_texture(&cont.texture_id.0, &cont.texture_id.1))
 													.position(cont.rect.pos.0, cont.rect.pos.1);
@@ -2366,7 +2381,7 @@ fn gen_army_troops(rng: &mut ThreadRng, units: &Vec<Unit>, army: usize) -> Vec<T
     );
     troops
 }
-fn gen_tilemap() -> (Tilemap<usize>, (u32, u32)) {
+fn gen_tilemap() -> (TileMap<usize>, (u32, u32)) {
     let noise = PerlinNoise::new();
     let mut rng = thread_rng();
     let seeds = (rng.gen_range(0..10000), rng.gen_range(0..10000));
@@ -2395,11 +2410,7 @@ fn gen_tilemap() -> (Tilemap<usize>, (u32, u32)) {
         .add(GenTile::new(4));
     let mut w = world.generate(0, 0).unwrap();
     (
-        w.iter_mut()
-            .map(|item| from_fn(|_| item.pop().unwrap()))
-            .collect::<Vec<_>>()
-            .try_into()
-            .unwrap(),
+        TileMap::new(w.into_iter().flatten()),
         seeds,
     )
 }
@@ -2580,26 +2591,27 @@ fn setup(app: &mut App, app_assets: &mut Assets, gfx: &mut Graphics) -> State {
     load_assets(gfx, &mut assets, req_assets.1, req_assets.0)
         .expect("Loading objects assets failed");
 
-    let (mut gamemap, gameevents) = parse_story(
-        &units,
-        &objects,
-        &settings.locale,
-        &settings.additional_locale,
-    );
+    // let (mut gamemap, gameevents) = parse_story(
+    //     &units,
+    //     &objects,
+    //     &settings.locale,
+    //     &settings.additional_locale,
+    // );
+	let (mut gamemap, gameevents) = (convert_dtm_map(parse_dtm_map(std::path::Path::new("./Maps_Rus/Проклятое озеро.DTm")).unwrap()), vec![]);
     gamemap.calc_hitboxes(&objects);
 
     let terrain = assets.get("assets/Terrain").unwrap();
     let mut draw: Draw = gfx.create_draw();
-    for i in 0..MAP_SIZE {
-        for j in 0..MAP_SIZE {
-            let asset = terrain.get(TILES[gamemap.tilemap[i][j]].sprite()).unwrap();
+    for i in 0..(gamemap.tilemap.size) {
+        for j in 0..(gamemap.tilemap.size) {
+            let asset = terrain.get(TILES[gamemap.tilemap[(i, j)]].sprite()).unwrap();
             draw.image(&*asset.lock().unwrap())
-                .position(i as f32 * 52., j as f32 * 40.)
-                .size(52., 40.);
+                .position(i as f32 * SIZE.0, j as f32 * SIZE.1)
+                .size(SIZE.0, SIZE.1);
         }
     }
     let texture = gfx
-        .create_render_texture(MAP_SIZE as u32 * 52, MAP_SIZE as u32 * 40)
+        .create_render_texture((gamemap.tilemap.size) as u32 * 52, (gamemap.tilemap.size) as u32 * 40)
         .build()
         .unwrap();
     gfx.render_to(&texture, &draw);