From 945ae96707f6b4065c89463047979a18ad8181aa Mon Sep 17 00:00:00 2001 From: Justin Worthe Date: Sun, 1 Jul 2018 21:37:24 +0200 Subject: Started implementation of reading bitwise from json --- src/input/json.rs | 162 ++++++++++++++++++++++++++++++++++-------------------- 1 file changed, 102 insertions(+), 60 deletions(-) (limited to 'src/input') diff --git a/src/input/json.rs b/src/input/json.rs index 319c77a..0ed86e7 100644 --- a/src/input/json.rs +++ b/src/input/json.rs @@ -4,6 +4,7 @@ use serde_json; use std::error::Error; use engine; +use engine::command; use engine::expressive_engine; use engine::bitwise_engine; @@ -14,53 +15,18 @@ pub fn read_expressive_state_from_file(filename: &str) -> Result<(engine::settin let state: State = serde_json::from_str(content.as_ref())?; let engine_settings = state.to_engine_settings(); - let engine_state = state.to_engine(&engine_settings); + let engine_state = state.to_expressive_engine(&engine_settings); Ok((engine_settings, engine_state)) } pub fn read_bitwise_state_from_file(filename: &str) -> Result> { - //TODO - Ok(bitwise_engine::BitwiseGameState { - status: engine::GameStatus::Continue, - player: engine::Player { - energy: 0, health: 0, energy_generated: 0 - }, - opponent: engine::Player { - energy: 0, health: 0, energy_generated: 0 - }, - player_buildings: bitwise_engine::PlayerBuildings { - unconstructed: Vec::new(), - buildings: [0,0,0,0], - energy_towers: 0, - missile_towers: [0,0,0,0], - missiles: [(0,0),(0,0),(0,0),(0,0)], - tesla_cooldowns: [bitwise_engine::TeslaCooldown { - active: false, - pos: engine::geometry::Point::new(0,0), - cooldown: 0 - }, bitwise_engine::TeslaCooldown { - active: false, - pos: engine::geometry::Point::new(0,0), - cooldown: 0 - }] - }, - opponent_buildings: bitwise_engine::PlayerBuildings { - unconstructed: Vec::new(), - buildings: [0,0,0,0], - energy_towers: 0, - missile_towers: [0,0,0,0], - missiles: [(0,0),(0,0),(0,0),(0,0)], - tesla_cooldowns: [bitwise_engine::TeslaCooldown { - active: false, - pos: engine::geometry::Point::new(0,0), - cooldown: 0 - }, bitwise_engine::TeslaCooldown { - active: false, - pos: engine::geometry::Point::new(0,0), - cooldown: 0 - }] - } - }) + let mut file = File::open(filename)?; + let mut content = String::new(); + file.read_to_string(&mut content)?; + let state: State = serde_json::from_str(content.as_ref())?; + + let engine_state = state.to_bitwise_engine(); + Ok(engine_state) } #[derive(Deserialize)] @@ -138,7 +104,7 @@ struct BuildingState { //destroy_multiplier: u32, //construction_score: u32, energy_generated_per_turn: u16, - //building_type: String, + building_type: String, x: u8, y: u8, player_type: char @@ -167,22 +133,63 @@ impl State { ) } - fn to_engine(&self, settings: &engine::settings::GameSettings) -> expressive_engine::ExpressiveGameState { - let player_buildings = self.buildings_to_engine('A'); - let opponent_buildings = self.buildings_to_engine('B'); + fn to_expressive_engine(&self, settings: &engine::settings::GameSettings) -> expressive_engine::ExpressiveGameState { + let player_buildings = self.buildings_to_expressive_engine('A'); + let opponent_buildings = self.buildings_to_expressive_engine('B'); expressive_engine::ExpressiveGameState::new( self.player().to_engine(settings, &player_buildings), self.opponent().to_engine(settings, &opponent_buildings), - self.unconstructed_buildings_to_engine('A'), + self.unconstructed_buildings_to_expressive_engine('A'), player_buildings, - self.unconstructed_buildings_to_engine('B'), + self.unconstructed_buildings_to_expressive_engine('B'), opponent_buildings, - self.missiles_to_engine('A'), - self.missiles_to_engine('B'), + self.missiles_to_expressive_engine('A'), + self.missiles_to_expressive_engine('B'), settings ) } + fn to_bitwise_engine(&self) -> bitwise_engine::BitwiseGameState { + let player_buildings = self.buildings_to_expressive_engine('A'); + let opponent_buildings = self.buildings_to_expressive_engine('B'); + bitwise_engine::BitwiseGameState::new( + self.player().to_bitwise_engine(), + self.opponent().to_bitwise_engine(), + bitwise_engine::PlayerBuildings { + unconstructed: self.unconstructed_buildings_to_bitwise_engine('A'), + buildings: [0,0,0,0], + energy_towers: 0, + missile_towers: [0,0,0,0], + missiles: [(0,0),(0,0),(0,0),(0,0)], + tesla_cooldowns: [bitwise_engine::TeslaCooldown { + active: false, + pos: engine::geometry::Point::new(0,0), + cooldown: 0 + }, bitwise_engine::TeslaCooldown { + active: false, + pos: engine::geometry::Point::new(0,0), + cooldown: 0 + }] + }, + bitwise_engine::PlayerBuildings { + unconstructed: Vec::new(), + buildings: [0,0,0,0], + energy_towers: 0, + missile_towers: [0,0,0,0], + missiles: [(0,0),(0,0),(0,0),(0,0)], + tesla_cooldowns: [bitwise_engine::TeslaCooldown { + active: false, + pos: engine::geometry::Point::new(0,0), + cooldown: 0 + }, bitwise_engine::TeslaCooldown { + active: false, + pos: engine::geometry::Point::new(0,0), + cooldown: 0 + }] + } + ) + } + fn player(&self) -> &Player { self.players.iter() .find(|p| p.player_type == 'A') @@ -195,34 +202,45 @@ impl State { .expect("Opponent character did not appear in state.json") } - fn unconstructed_buildings_to_engine(&self, player_type: char) -> Vec { + fn unconstructed_buildings_to_expressive_engine(&self, player_type: char) -> Vec { self.game_map.iter() .flat_map(|row| row.iter() .flat_map(|cell| cell.buildings.iter() .filter(|b| b.player_type == player_type && b.construction_time_left >= 0) - .map(|b| b.to_engine_unconstructed()) + .map(|b| b.to_expressive_engine_unconstructed()) + ) + ) + .collect() + } + + fn unconstructed_buildings_to_bitwise_engine(&self, player_type: char) -> Vec { + self.game_map.iter() + .flat_map(|row| row.iter() + .flat_map(|cell| cell.buildings.iter() + .filter(|b| b.player_type == player_type && b.construction_time_left >= 0) + .map(|b| b.to_bitwise_engine_unconstructed()) ) ) .collect() } - fn buildings_to_engine(&self, player_type: char) -> Vec { + fn buildings_to_expressive_engine(&self, player_type: char) -> Vec { self.game_map.iter() .flat_map(|row| row.iter() .flat_map(|cell| cell.buildings.iter() .filter(|b| b.player_type == player_type && b.construction_time_left < 0) - .map(|b| b.to_engine()) + .map(|b| b.to_expressive_engine()) ) ) .collect() } - fn missiles_to_engine(&self, player_type: char) -> Vec { + fn missiles_to_expressive_engine(&self, player_type: char) -> Vec { self.game_map.iter() .flat_map(|row| row.iter() .flat_map(|cell| cell.missiles.iter() .filter(|b| b.player_type == player_type) - .map(|b| b.to_engine()) + .map(|b| b.to_expressive_engine()) ) ) .collect() @@ -251,10 +269,17 @@ impl Player { energy_generated: settings.energy_income + buildings.iter().map(|b| b.energy_generated_per_turn).sum::() } } + fn to_bitwise_engine(&self) -> engine::Player { + engine::Player { + energy: self.energy, + health: self.health, + energy_generated: 5 + } + } } impl BuildingState { - fn to_engine(&self) -> expressive_engine::Building { + fn to_expressive_engine(&self) -> expressive_engine::Building { expressive_engine::Building { pos: engine::geometry::Point::new(self.x, self.y), health: self.health, @@ -266,7 +291,7 @@ impl BuildingState { } } - fn to_engine_unconstructed(&self) -> expressive_engine::UnconstructedBuilding { + fn to_expressive_engine_unconstructed(&self) -> expressive_engine::UnconstructedBuilding { expressive_engine::UnconstructedBuilding { pos: engine::geometry::Point::new(self.x, self.y), health: self.health, @@ -277,10 +302,27 @@ impl BuildingState { energy_generated_per_turn: self.energy_generated_per_turn, } } + + fn to_bitwise_engine_unconstructed(&self) -> bitwise_engine::UnconstructedBuilding { + bitwise_engine::UnconstructedBuilding { + pos: engine::geometry::Point::new(self.x, self.y), + construction_time_left: self.construction_time_left as u8, // > 0 check already happened + building_type: self.convert_building_type() + } + } + + fn convert_building_type(&self) -> command::BuildingType { + match self.building_type.as_ref() { + "ATTACK" => command::BuildingType::Attack, + "ENERGY" => command::BuildingType::Energy, + "TESLA" => command::BuildingType::Tesla, + _ => command::BuildingType::Defence, + } + } } impl MissileState { - fn to_engine(&self) -> expressive_engine::Missile { + fn to_expressive_engine(&self) -> expressive_engine::Missile { expressive_engine::Missile { pos: engine::geometry::Point::new(self.x, self.y), damage: self.damage, -- cgit v1.2.3