September 2018 game update

screeps-game-api/Cargo.toml

@@ -27,6 +27,7 @@ log = "0.4"
 num-traits = "0.2"
 serde = "1"
 serde_derive = "1"
+serde_json = "1"
 scoped-tls = "0.1"
 stdweb = "0.4"
 stdweb-derive = "0.5"

screeps-game-api/javascript/utils.js

@@ -192,15 +192,6 @@ function __resource_type_str_to_num(str) {
     }
 }
 
-function __terrain_type_str_to_num(str) {
-    switch (str) {
-        case "plain": return 0;
-        case "wall": return 1;
-        case "swamp": return 2;
-        default: throw new Error("unknown terrain type " + str);
-    }
-}
-
 function _hasActiveBodypart(body, type) {
     for (var i = body.length - 1; i >= 0; i--) {
         if (body[i].hits <= 0) {

screeps-game-api/src/constants.rs

@@ -250,6 +250,9 @@ pub enum Terrain {
     Plain = 0,
     Wall = 1,
     Swamp = 2,
+    SwampWall = 3,
+    Lava = 4,
+    // Todo: Implement the other masks when lava becomes a thing
 }
 
 impl TryFrom<Value> for Terrain {
@@ -267,26 +270,15 @@ impl TryFrom<Value> for Terrain {
                 0 => Terrain::Plain,
                 1 => Terrain::Wall,
                 2 => Terrain::Swamp,
-                // might not need this, but just in case we try
-                // to decode a game-encoded number and '3' represents swamp + wall
-                3 => Terrain::Wall,
+                3 => Terrain::SwampWall,
+                4 => Terrain::Lava,
                 x => panic!("unknown terrain encoded integer {}", x),
             },
         };
         Ok(v)
     }
 }
 
-impl AsRef<str> for Terrain {
-    fn as_ref(&self) -> &str {
-        match *self {
-            Terrain::Plain => "plain",
-            Terrain::Wall => "wall",
-            Terrain::Swamp => "swamp",
-        }
-    }
-}
-
 /// Internal enum representing each LOOK_* constant.
 ///
 /// It's recommended to use the constants in the `look` module instead for type safety.

screeps-game-api/src/game.rs

@@ -130,8 +130,8 @@ pub mod map {
     use std::collections;
 
     use {
-        constants::{find::Exit, Direction, ReturnCode, Terrain},
-        objects::{Room, RoomPosition},
+        constants::{find::Exit, Direction, ReturnCode},
+        objects::{Room, RoomTerrain},
         traits::{TryFrom, TryInto},
     };
 
@@ -164,11 +164,8 @@ pub mod map {
         js_unwrap!(Game.map.getRoomLinearDistance(@{room1}, @{room2}, @{continuous}))
     }
 
-    /// See [http://docs.screeps.com/api/#Game.map.getTerrainAt]
-    ///
-    /// [http://docs.screeps.com/api/#Game.map.getTerrainAt]: http://docs.screeps.com/api/#Game.map.getTerrainAt
-    pub fn get_terrain_at(pos: &RoomPosition) -> Terrain {
-        js_unwrap!(__terrain_type_str_to_num(Game.map.getTerrainAt(@{pos.as_ref()})))
+    pub fn get_room_terrain(room_name: &str) -> RoomTerrain {
+        js_unwrap!(Game.map.getRoomTerrain(@{room_name}))
     }
 
     /// See [http://docs.screeps.com/api/#Game.map.getWorldSize]

screeps-game-api/src/lib.rs

@@ -28,6 +28,7 @@ extern crate scoped_tls;
 extern crate serde;
 #[macro_use]
 extern crate serde_derive;
+extern crate serde_json;
 #[macro_use]
 extern crate stdweb;
 #[macro_use]

screeps-game-api/src/objects/impls/mod.rs

@@ -7,6 +7,7 @@ mod nuke;
 mod resource;
 mod room;
 mod room_position;
+mod room_terrain;
 mod source;
 mod structure_controller;
 mod structure_keeper_lair;
@@ -24,7 +25,11 @@ mod structure_tower;
 mod tombstone;
 
 pub use self::{
-    room::{FindOptions, Path, Step},
+    room::{
+        AttackEvent, AttackType, BuildEvent, Event, EventType, ExitEvent, FindOptions,
+        HarvestEvent, HealEvent, HealType, ObjectDestroyedEvent, Path, RepairEvent,
+        ReserveControllerEvent, Step, UpgradeControllerEvent,
+    },
     structure_controller::{Reservation, Sign},
     structure_spawn::SpawnOptions,
 };

screeps-game-api/src/objects/impls/room.rs

@@ -1,5 +1,6 @@
 use std::{marker::PhantomData, mem, ops::Range};
 
+use serde_json;
 use stdweb::Reference;
 
 use {
@@ -8,7 +9,8 @@ use {
     },
     memory::MemoryReference,
     objects::{
-        HasPosition, Room, RoomPosition, StructureController, StructureStorage, StructureTerminal,
+        HasPosition, Room, RoomPosition, RoomTerrain, StructureController, StructureStorage,
+        StructureTerminal,
     },
     pathfinder::CostMatrix,
     positions::LocalRoomName,
@@ -102,10 +104,19 @@ impl Room {
         }
     }
 
+    pub fn get_event_log(&self) -> Vec<Event> {
+        let raw_event_log: String = js_unwrap!{@{self.as_ref()}.getEventLog(true)};
+        serde_json::from_str(&raw_event_log).expect("Malformed Event Log")
+    }
+
     pub fn get_position_at(&self, x: u32, y: u32) -> Option<RoomPosition> {
         js_unwrap!{@{self.as_ref()}.get_position_at(@{x}, @{y})}
     }
 
+    pub fn get_terrain(&self) -> RoomTerrain {
+        js_unwrap!(@{self.as_ref()}.getTerrain())
+    }
+
     // pub fn look_at(&self, x: u32, y: u32) -> ! {
     //     unimplemented!()
     // }
@@ -420,3 +431,120 @@ pub enum Path {
 }
 
 js_deserializable!{Path}
+
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize)]
+pub struct Event {
+    #[serde(flatten)]
+    pub event: EventType,
+    #[serde(rename = "objectId")]
+    pub object_id: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize)]
+#[serde(tag = "event", content = "data")]
+pub enum EventType {
+    #[serde(rename = "1")]
+    Attack(AttackEvent),
+    #[serde(rename = "2")]
+    ObjectDestroyed(ObjectDestroyedEvent),
+    #[serde(rename = "3")]
+    AttackController,
+    #[serde(rename = "4")]
+    Build(BuildEvent),
+    #[serde(rename = "5")]
+    Harvest(HarvestEvent),
+    #[serde(rename = "6")]
+    Heal(HealEvent),
+    #[serde(rename = "7")]
+    Repair(RepairEvent),
+    #[serde(rename = "8")]
+    ReserveController(ReserveControllerEvent),
+    #[serde(rename = "9")]
+    UpgradeController(UpgradeControllerEvent),
+    #[serde(rename = "10")]
+    Exit(ExitEvent),
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct AttackEvent {
+    pub target_id: String,
+    pub damage: u32,
+    pub attack_type: AttackType,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Deserialize)]
+#[repr(u32)]
+pub enum AttackType {
+    Melee = 1,
+    Ranged = 2,
+    RangedMass = 3,
+    Dismantle = 4,
+    HitBack = 5,
+    Nuke = 6,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize)]
+pub struct ObjectDestroyedEvent {
+    #[serde(rename = "type")]
+    pub object_type: String,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct BuildEvent {
+    pub target_id: String,
+    pub amount: u32,
+    pub energy_spent: u32,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct HarvestEvent {
+    pub target_id: String,
+    pub amount: u32,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct HealEvent {
+    pub target_id: String,
+    pub amount: u32,
+    pub heal_type: HealType,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Deserialize)]
+#[repr(u32)]
+pub enum HealType {
+    Melee = 1,
+    Ranged = 2,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct RepairEvent {
+    pub target_id: String,
+    pub amount: u32,
+    pub energy_spent: u32,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ReserveControllerEvent {
+    pub amount: u32,
+}
+
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct UpgradeControllerEvent {
+    pub amount: u32,
+    pub energy_spent: u32,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct ExitEvent {
+    pub room: String,
+    pub x: u32,
+    pub y: u32,
+}

screeps-game-api/src/objects/impls/room_position.rs

@@ -42,6 +42,13 @@ impl RoomPosition {
         )
     }
 
+    pub fn create_named_construction_site(&self, ty: StructureType, name: &str) -> ReturnCode {
+        js_unwrap!(
+            @{self.as_ref()}.createConstructionSite(__structure_type_num_to_str(@{ty as i32}),
+                                                    @{name})
+        )
+    }
+
     pub fn create_flag(&self, name: &str, main_color: Color, secondary_color: Color) -> ReturnCode {
         // TODO: determine if ERR_NOT_IN_RANGE is the best choice here
         (js! {

screeps-game-api/src/objects/impls/room_terrain.rs

@@ -0,0 +1,15 @@
+use {constants::Terrain, objects::RoomTerrain};
+
+impl RoomTerrain {
+    pub fn constructor(room_name: &str) -> Self {
+        js_unwrap!{new Room.Terrain(@{room_name})}
+    }
+
+    pub fn get(&self, x: u32, y: u32) -> Terrain {
+        js_unwrap!{@{self.as_ref()}.get(@{x}, @{y})}
+    }
+
+    pub fn get_raw_buffer(&self) -> Vec<u8> {
+        js_unwrap!(@{self.as_ref()}.getRawBuffer())
+    }
+}

screeps-game-api/src/objects/impls/structure_lab.rs

@@ -27,4 +27,8 @@ impl StructureLab {
     pub fn run_reaction(&self, lab1: &StructureLab, lab2: &StructureLab) -> ReturnCode {
         js_unwrap!{@{self.as_ref()}.runReaction(@{lab1.as_ref()}, @{lab2.as_ref()})}
     }
+
+    pub fn unboost_creep(&self, creep: &Creep) -> ReturnCode {
+        js_unwrap!(@{self.as_ref()}.unboostCreep(@{creep.as_ref()}))
+    }
 }

screeps-game-api/src/objects/mod.rs

@@ -24,7 +24,11 @@ mod impls;
 mod structure;
 
 pub use self::{
-    impls::{FindOptions, Path, Reservation, Sign, SpawnOptions, Step},
+    impls::{
+        AttackEvent, AttackType, BuildEvent, Event, EventType, ExitEvent, FindOptions,
+        HarvestEvent, HealEvent, HealType, ObjectDestroyedEvent, Path, RepairEvent, Reservation,
+        ReserveControllerEvent, Sign, SpawnOptions, Step, UpgradeControllerEvent,
+    },
     structure::Structure,
 };
 
@@ -49,6 +53,8 @@ reference_wrappers!(
     RoomObject,
     #[reference(instance_of = "RoomPosition")]
     RoomPosition,
+    #[reference(instance_of = "Room.Terrain")]
+    RoomTerrain,
     #[reference(instance_of = "Source")]
     Source,
     #[reference(instance_of = "StructureContainer")]