radar: Support scanning bot orientations

app/crates/kartoffel/src/radar.rs

@@ -1,6 +1,42 @@
 use crate::{cmd, rdi, wri, MEM_RADAR};
 use core::num::NonZeroU64;
 
+/// When enabled, this option causes the radar to scan the surrounding tiles.
+///
+/// This option is enabled by default - it's active when you call
+/// [`radar_scan()`], but you can disable it through [`radar_scan_ex()`].
+///
+/// This options adds 10k ticks of cooldown.
+pub const RADAR_SCAN_TILES: u8 = 1;
+
+/// When enabled, this option causes the radar to scan the surrounding bots.
+///
+/// This option is enabled by default - it's active when you call
+/// [`radar_scan()`], but you can disable it through [`radar_scan_ex()`].
+///
+/// This option adds 10k ticks of cooldown.
+pub const RADAR_SCAN_BOTS: u8 = 2;
+
+/// When enabled, this option causes the radar to scan the surrounding objects
+/// (e.g. a diamond).
+///
+/// This option is enabled by default - it's active when you call
+/// [`radar_scan()`], but you can disable it through [`radar_scan_ex()`].
+///
+/// This option adds 10k ticks of cooldown.
+pub const RADAR_SCAN_OBJECTS: u8 = 4;
+
+/// When enabled, this option causes the radar to scan the directions the
+/// surrounding bots are facing.
+///
+/// TODO
+///
+/// This option requires [`RADAR_SCAN_BOTS`].
+///
+/// This option is disabled by default - you need to call [`radar_scan_ex()`]
+/// to use it.
+pub const RADAR_SCAN_BOT_DIRS: u8 = 8;
+
 /// Returns whether the radar is ready and [`radar_scan()`] can be invoked.
 ///
 /// See also: [`radar_wait()`].
@@ -21,12 +57,11 @@ pub fn radar_wait() {
 
 /// Scans a square around the bot.
 ///
-/// This function performs an `r x r` scan, so e.g. `r=3` will do a `3x3` scan.
-/// Legal values of `r` are 3, 5, 7 or 9 - other values will cause the CPU to
-/// crash.
+/// This performs an `r x r` scan, so e.g. `r=3` will do a `3x3` scan. Legal
+/// values of `r` are 3, 5, 7 or 9 - other values will cause the CPU to crash.
 ///
 /// Note that this is a low-level function - for convenience you'll most likely
-/// want to use one of:
+/// want to use [`RadarScan`] through:
 ///
 /// - [`radar_scan_3x3()`],
 /// - [`radar_scan_5x5()`],
@@ -41,6 +76,12 @@ pub fn radar_scan(r: u8) {
     wri(MEM_RADAR, 0, cmd(0x01, r, 0x00, 0x00));
 }
 
+/// Scans a square around the bot, with custom options.
+#[inline(always)]
+pub fn radar_scan_ex(r: u8, m: u8) {
+    wri(MEM_RADAR, 0, cmd(0x01, r, m, 0x00));
+}
+
 /// Scans a 3x3 square around the bot and returns the scanned area.
 ///
 /// # Cooldown
@@ -238,6 +279,14 @@ pub struct RadarScan<const R: usize> {
 }
 
 impl<const R: usize> RadarScan<R> {
+    pub fn new() -> Self {
+        Self { _priv: () }
+    }
+
+    // pub fn at_ex(&self, dx: i8, dy: i8) -> [u8; 4] {
+    //
+    // }
+
     /// Returns the topmost thing visible at given coordinates:
     ///
     /// - if there's a bot, returns `'@'`,
@@ -270,4 +319,8 @@ impl<const R: usize> RadarScan<R> {
 
         NonZeroU64::new((d1 << 32) | d2)
     }
+
+    pub fn bot_dir_at(&self, dx: i8, dy: i8) -> char {
+        todo!();
+    }
 }

app/crates/kartoffels-world/Cargo.toml

@@ -14,6 +14,7 @@ derivative.workspace = true
 futures-util.workspace = true
 glam = { workspace = true, features = ["serde"] }
 itertools.workspace = true
+kartoffel = { path = "../kartoffel" }
 kartoffels-cpu = { path = "../kartoffels-cpu" }
 kartoffels-utils = { path = "../kartoffels-utils" }
 maybe-owned.workspace = true

app/crates/kartoffels-world/src/bot/radar.rs

@@ -34,11 +34,11 @@ impl BotRadar {
         val: u32,
     ) -> Result<(), ()> {
         match (addr, val.to_le_bytes()) {
-            (AliveBot::MEM_RADAR, [0x01, range, 0x00, 0x00])
+            (AliveBot::MEM_RADAR, [0x01, range, mode, 0x00])
                 if let Some(range) = BotRadarRange::new(range) =>
             {
                 if self.cooldown == 0 {
-                    self.do_scan(ctxt, range);
+                    self.scan(ctxt, range, BotRadarMode::from(mode));
                 }
 
                 Ok(())
@@ -48,7 +48,12 @@ impl BotRadar {
         }
     }
 
-    fn do_scan(&mut self, ctxt: &mut BotMmioContext, range: BotRadarRange) {
+    fn scan(
+        &mut self,
+        ctxt: &mut BotMmioContext,
+        range: BotRadarRange,
+        mode: BotRadarMode,
+    ) {
         for y in 0..range.len() {
             for x in 0..range.len() {
                 let pos = {
@@ -58,24 +63,32 @@ impl BotRadar {
                     ctxt.pos + ctxt.dir.as_vec().rotate(offset.perp())
                 };
 
-                let out_z0;
-                let out_z1;
-                let out_z2;
-
-                if let Some(bot_id) = ctxt.bots.lookup_at(pos) {
-                    let bot_id = bot_id.get().get();
-
-                    out_z0 = TileKind::BOT as u32;
-                    out_z1 = (bot_id >> 32) as u32;
-                    out_z2 = bot_id as u32;
-                } else if let Some(object) = ctxt.objects.get_at(pos) {
+                let mut out_z0 = 0;
+                let mut out_z1 = 0;
+                let mut out_z2 = 0;
+
+                if mode.bots
+                    && let Some(id) = ctxt.bots.lookup_at(pos)
+                {
+                    out_z0 = if mode.bot_dirs {
+                        let dir =
+                            ctxt.bots.get(id).unwrap().dir.as_caret() as u8;
+
+                        u32::from_le_bytes([TileKind::BOT, dir, 0, 0])
+                    } else {
+                        u32::from_le_bytes([TileKind::BOT, 0, 0, 0])
+                    };
+
+                    let id = id.get().get();
+
+                    out_z1 = (id >> 32) as u32;
+                    out_z2 = id as u32;
+                } else if mode.objects
+                    && let Some(object) = ctxt.objects.get_at(pos)
+                {
                     out_z0 = object.kind as u32;
-                    out_z1 = 0;
-                    out_z2 = 0;
-                } else {
+                } else if mode.tiles {
                     out_z0 = ctxt.map.get(pos).kind as u32;
-                    out_z1 = 0;
-                    out_z2 = 0;
                 }
 
                 self.scan[range.idx(x, y, 0)] = out_z0;
@@ -84,7 +97,18 @@ impl BotRadar {
             }
         }
 
-        self.cooldown = range.cooldown(ctxt);
+        self.cooldown = ctxt.cooldown(Self::cooldown(range, mode), 15);
+    }
+
+    fn cooldown(range: BotRadarRange, mode: BotRadarMode) -> u32 {
+        let base = match range {
+            BotRadarRange::D3 => 10_000,
+            BotRadarRange::D5 => 15_000,
+            BotRadarRange::D7 => 22_000,
+            BotRadarRange::D9 => 30_000,
+        };
+
+        todo!();
     }
 }
 
@@ -126,13 +150,32 @@ impl BotRadarRange {
 
         (z * len * len + y * len + x) as usize
     }
+}
+
+#[derive(Clone, Copy, Debug)]
+struct BotRadarMode {
+    tiles: bool,
+    bots: bool,
+    objects: bool,
+    bot_dirs: bool,
+}
 
-    fn cooldown(&self, ctxt: &mut BotMmioContext) -> u32 {
-        match self {
-            Self::D3 => ctxt.cooldown(10_000, 10),
-            Self::D5 => ctxt.cooldown(15_000, 15),
-            Self::D7 => ctxt.cooldown(22_000, 25),
-            Self::D9 => ctxt.cooldown(30_000, 30),
+impl From<u8> for BotRadarMode {
+    fn from(mode: u8) -> Self {
+        if mode == 0 {
+            Self {
+                tiles: true,
+                bots: true,
+                objects: true,
+                bot_dirs: false,
+            }
+        } else {
+            Self {
+                tiles: (mode & kartoffel::RADAR_SCAN_TILES) > 0,
+                bots: (mode & kartoffel::RADAR_SCAN_BOTS) > 0,
+                objects: (mode & kartoffel::RADAR_SCAN_OBJECTS) > 0,
+                bot_dirs: (mode & kartoffel::RADAR_SCAN_BOT_DIRS) > 0,
+            }
         }
     }
 }

app/crates/kartoffels-world/src/utils/dir.rs

@@ -73,6 +73,16 @@ impl Dir {
             Dir::W => ivec2(-1, 0),
         }
     }
+
+    #[must_use]
+    pub fn as_caret(&self) -> char {
+        match self {
+            Dir::N => '^',
+            Dir::E => '>',
+            Dir::S => 'v',
+            Dir::W => '<',
+        }
+    }
 }
 
 impl fmt::Display for Dir {