From f1f81abab3ca1c1f97ccd52e99c3977905312d94 Mon Sep 17 00:00:00 2001
From: Justin Worthe <justin@worthe-it.co.za>
Date: Mon, 25 Jun 2018 17:37:14 +0200
Subject: Added new tower type and deconstruct action

---
 src/engine/command.rs  | 10 ++++++----
 src/engine/mod.rs      | 27 +++++++++++++++++++++++++++
 src/engine/settings.rs | 10 ++++++----
 3 files changed, 39 insertions(+), 8 deletions(-)

(limited to 'src/engine')

diff --git a/src/engine/command.rs b/src/engine/command.rs
index b350d65..7a2594d 100644
--- a/src/engine/command.rs
+++ b/src/engine/command.rs
@@ -5,6 +5,7 @@ use super::geometry::Point;
 pub enum Command {
     Nothing,
     Build(Point, BuildingType),
+    Deconstruct(Point)
 }
 
 impl fmt::Display for Command {
@@ -12,6 +13,7 @@ impl fmt::Display for Command {
         match *self {
             Command::Nothing => write!(f, ""),
             Command::Build(p, b) => write!(f, "{},{},{}", p.x, p.y, b as u8),
+            Command::Deconstruct(p) => write!(f, "3,{},{}", p.x, p.y),
         }
     }
 }
@@ -22,18 +24,18 @@ pub enum BuildingType {
     Defence = 0,
     Attack = 1,
     Energy = 2,
+    Tesla = 4,
 }
 
 impl BuildingType {
-    pub fn all() -> [BuildingType; 3] {
+    pub fn all() -> [BuildingType; 4] {
         use self::BuildingType::*;
-        [Defence, Attack, Energy]
+        [Defence, Attack, Energy, Tesla]
     }
 
-    fn count() -> u8 { BuildingType::Energy as u8 + 1 }
     pub fn from_u8(id: u8) -> Option<BuildingType> {
         use std::mem;
-        if id < Self::count() { Some(unsafe { mem::transmute(id) }) } else { None }
+        if id < 4 && id != 3 { Some(unsafe { mem::transmute(id) }) } else { None }
     }
 
 }
diff --git a/src/engine/mod.rs b/src/engine/mod.rs
index 739dd85..2a334d5 100644
--- a/src/engine/mod.rs
+++ b/src/engine/mod.rs
@@ -122,6 +122,8 @@ impl GameState {
         GameState::update_construction(&mut self.player_unconstructed_buildings, &mut self.player_buildings, &mut self.player);
         GameState::update_construction(&mut self.opponent_unconstructed_buildings, &mut self.opponent_buildings, &mut self.opponent);
 
+        GameState::fire_teslas(&mut self.player_buildings, &mut self.opponent_buildings);
+
         GameState::add_missiles(&mut self.player_buildings, &mut self.player_missiles);
         GameState::add_missiles(&mut self.opponent_buildings, &mut self.opponent_missiles);
 
@@ -161,6 +163,22 @@ impl GameState {
                 let to_remove_index = unoccupied_cells.iter().position(|&pos| pos == p).unwrap();
                 unoccupied_cells.swap_remove(to_remove_index);
             },
+            Command::Deconstruct(p) => {
+                let to_remove_index = buildings.iter().position(|&pos| pos == p);
+                if let Some(i) = to_remove_index {
+                    buildings.swap_remove(i);
+                }
+                let unconstructed_to_remove_index = unconstructed_buildings.iter().position(|&pos| pos == p);
+                if let Some(i) = unconstructed_to_remove_index {
+                    unconstructed_buildings.swap_remove(i);
+                }
+                
+                debug_assert!(to_remove_index.is_some() || unconstructed_to_remove_index.is_some());
+                    
+                player.energy += 5;
+                
+                unoccupied_cells.push(p);
+            },
         }
     }
 
@@ -179,6 +197,15 @@ impl GameState {
         unconstructed_buildings.truncate(buildings_len);
     }
 
+    fn fire_teslas(_player_buildings: &mut Vec<Building>, _opponent_buildings: &mut Vec<Building>) {
+        // TODO all towers try to fire. If there isn't enough energy
+        // to fire multiple, the oldest fires. This seems like an edge
+        // case because you're only allowed two towers in total, and
+        // they're probably only late game towers. The odds of firing
+        // twice at once is slim. Opposing towers can't be stopped
+        // from firing by firing themselves. So fire all, then remove.
+    }
+        
     fn add_missiles(buildings: &mut Vec<Building>, missiles: &mut Vec<Missile>) {
         for building in buildings.iter_mut().filter(|b| b.is_shooty()) {
             if building.weapon_cooldown_time_left > 0 {
diff --git a/src/engine/settings.rs b/src/engine/settings.rs
index ec62408..3657cb2 100644
--- a/src/engine/settings.rs
+++ b/src/engine/settings.rs
@@ -9,7 +9,8 @@ pub struct GameSettings {
     pub max_building_price: u16,
     pub energy: BuildingSettings,
     pub defence: BuildingSettings,
-    pub attack: BuildingSettings
+    pub attack: BuildingSettings,
+    pub tesla: BuildingSettings,
 }
 
 #[derive(Debug)]
@@ -24,18 +25,19 @@ pub struct BuildingSettings {
 }
 
 impl GameSettings {
-    pub fn new(size: Point, energy_income: u16, energy: BuildingSettings, defence: BuildingSettings, attack: BuildingSettings) -> GameSettings {
+    pub fn new(size: Point, energy_income: u16, energy: BuildingSettings, defence: BuildingSettings, attack: BuildingSettings, tesla: BuildingSettings) -> GameSettings {
         let max_building_price = cmp::max(cmp::max(energy.price, defence.price), attack.price);
         GameSettings {
             size, energy_income, max_building_price,
-            energy, defence, attack
+            energy, defence, attack, tesla
         }
     }
     pub fn building_settings(&self, building: BuildingType) -> &BuildingSettings {
         match building {
             BuildingType::Defence => &self.defence,
             BuildingType::Attack => &self.attack,
-            BuildingType::Energy => &self.energy
+            BuildingType::Energy => &self.energy,
+            BuildingType::Tesla => &self.tesla,
         }
     }
     
-- 
cgit v1.2.3