gameplay: port recent record awards

crates/urt-gameplay/src/bin/urt-lifecycle.rs

@@ -223,6 +223,52 @@ fn run() -> Result<(), String> {
                 n.ratio.to_bits()
             );
         }
+        "award" if w.len() == 7 && w[6] <= 1 => {
+            use urt_gameplay::recent_awards::{Client, Rows, award};
+            let index = w[1] as i32;
+            let key = if (0..=64).contains(&index) {
+                index as usize
+            } else {
+                0
+            };
+            let mut rows: Rows = std::array::from_fn(|j| {
+                if [0, 1, 2, 3, 64].contains(&j) && (j != 2 || w[6] != 0) {
+                    let mut pairs = [[0; 2]; 65];
+                    pairs[64][0] = w[4] as i32;
+                    pairs[key] = [w[2] as i32, (w[5] as i32).wrapping_sub(w[3] as i32)];
+                    Some(Client {
+                        id: j as i32,
+                        team: if j == 1 || j == 64 { 1 } else { 2 },
+                        pairs,
+                    })
+                } else {
+                    None
+                }
+            });
+            let awards = award(w[0] as i32, index, 2, w[5] as i32, &mut rows)
+                .map_err(|e| format!("unsupported input: {e:?}"))?;
+            let intents: Vec<_> = awards
+                .iter()
+                .map(|a| format!("[{},{},{}]", a.recipient, a.offender, a.victim))
+                .collect();
+            let values: Vec<_> = rows
+                .iter()
+                .enumerate()
+                .filter_map(|(j, r)| {
+                    r.as_ref().map(|r| {
+                        format!(
+                            "{{\"slot\":{},\"awards\":{},\"count\":{}}}",
+                            j, r.pairs[64][0] as u32, r.pairs[key][0] as u32
+                        )
+                    })
+                })
+                .collect();
+            println!(
+                "{{\"awards\":[{}],\"rows\":[{}]}}",
+                intents.join(","),
+                values.join(",")
+            );
+        }
         _ => return Err("unsupported contract or arguments".into()),
     }
     Ok(())

crates/urt-gameplay/src/lib.rs

@@ -149,6 +149,7 @@ pub mod intercept_animation;
 pub mod method_stats;
 pub mod mode10;
 pub mod protected;
+pub mod recent_awards;
 pub mod record_clear;
 pub mod score;
 pub mod stat_totals;

crates/urt-gameplay/src/recent_awards.rs

@@ -0,0 +1,130 @@
+//! Source285227 record eligibility and award intent, without logging/networking.
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Client {
+    pub id: i32,
+    pub team: i32,
+    pub pairs: [[i32; 2]; 65],
+}
+pub type Rows = [Option<Client>; 65];
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub struct Award {
+    pub recipient: i32,
+    pub offender: i32,
+    pub victim: i32,
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum AwardError {
+    UnsupportedOffender,
+}
+/// Rows0..63 are recipients; row64 is accepted as the victim. Pair64[0]
+/// aliases the award counter, preserving the source3032 storage overlap.
+pub fn award(
+    mode: i32,
+    index: i32,
+    offender: i32,
+    now: i32,
+    rows: &mut Rows,
+) -> Result<Vec<Award>, AwardError> {
+    let Ok(index) = usize::try_from(index) else {
+        return Ok(vec![]);
+    };
+    if index > 64 || mode < 3 || mode == 9 || mode == 11 {
+        return Ok(vec![]);
+    }
+    let Some(victim) = rows[index].as_ref() else {
+        return Ok(vec![]);
+    };
+    let (victim_id, victim_team) = (victim.id, victim.team);
+    let actor_index = usize::try_from(offender)
+        .ok()
+        .filter(|i| *i <= 64)
+        .ok_or(AwardError::UnsupportedOffender)?;
+    let Some(actor) = rows[actor_index].as_ref() else {
+        return Ok(vec![]);
+    };
+    let actor_id = actor.id;
+    let mut requests = vec![];
+    for row in rows.iter_mut().take(64).flatten() {
+        if row.id == offender
+            || row.team == victim_team
+            || row.pairs[index][0] < 40
+            || now.wrapping_sub(row.pairs[index][1]) > 30000
+        {
+            continue;
+        }
+        row.pairs[64][0] = row.pairs[64][0].wrapping_add(1);
+        requests.push(Award {
+            recipient: row.id,
+            offender: actor_id,
+            victim: victim_id,
+        });
+    }
+    Ok(requests)
+}
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn rows() -> Rows {
+        std::array::from_fn(|j| {
+            if [0, 1, 2, 64].contains(&j) {
+                let mut pairs = [[0; 2]; 65];
+                pairs[1] = [40, 10000];
+                pairs[64] = [40, 10000];
+                Some(Client {
+                    id: j as i32,
+                    team: if j == 1 || j == 64 { 1 } else { 2 },
+                    pairs,
+                })
+            } else {
+                None
+            }
+        })
+    }
+    #[test]
+    fn inclusive64_and_alias_counter() {
+        let mut r = rows();
+        assert_eq!(
+            award(10, 64, 2, 40000, &mut r).unwrap(),
+            vec![Award {
+                recipient: 0,
+                offender: 2,
+                victim: 64
+            }]
+        );
+        assert_eq!(r[0].unwrap().pairs[64], [41, 10000]);
+    }
+    #[test]
+    fn future_timestamp_and_counter_wrap() {
+        let mut r = rows();
+        r[0].as_mut().unwrap().pairs[1][1] = 40001;
+        r[0].as_mut().unwrap().pairs[64][0] = -1;
+        assert_eq!(award(10, 1, 2, 40000, &mut r).unwrap().len(), 1);
+        assert_eq!(r[0].unwrap().pairs[64][0], 0);
+    }
+    #[test]
+    fn strict_age_and_count_thresholds() {
+        let mut r = rows();
+        let original = r;
+        r[0].as_mut().unwrap().pairs[1][1] = 9999;
+        assert!(award(10, 1, 2, 40000, &mut r).unwrap().is_empty());
+        let mut r = original;
+        r[0].as_mut().unwrap().pairs[1][0] = 39;
+        assert!(award(10, 1, 2, 40000, &mut r).unwrap().is_empty());
+    }
+    #[test]
+    fn gates_missing_actor_and_unsupported_offender() {
+        for (mode, index) in [(9, 1), (11, 1), (2, 1), (10, -1), (10, 65)] {
+            let mut r = rows();
+            let before = r;
+            assert!(award(mode, index, -1, 40000, &mut r).unwrap().is_empty());
+            assert_eq!(r, before);
+        }
+        let mut r = rows();
+        r[2] = None;
+        assert!(award(10, 1, 2, 40000, &mut r).unwrap().is_empty());
+        assert_eq!(
+            award(10, 1, -1, 40000, &mut r),
+            Err(AwardError::UnsupportedOffender)
+        );
+    }
+}

docs/ASSET_PIPELINE_TODO.md

@@ -955,3 +955,6 @@ Research progress: RE-764 [report](research/QVM_RANKING_SETUP.md); original asse
 
 
 Research progress: RE-765 [report](research/RUST_STAT_TOTALS.md); original assets unchanged.
+
+
+Research progress: RE-766 [report](research/RUST_RECENT_AWARDS.md); original assets unchanged.

docs/FINDINGS.md

@@ -1301,3 +1301,6 @@ RE-725–734 batch: [health, contact and Rust impulse findings](research/QVM_HEA
 
 
 **RE-765 — Rust counter totals divisor and normalized ratio primitives:** Rust totals and normalized ratios match80 total,28 ratio and38 signed-divisor source fixtures while retaining20 slots. [Evidence](research/RUST_STAT_TOTALS.md).
+
+
+**RE-766 — Rust recent record awards timestamp gates and alias storage:** Rust recent-record awards match68 source fixtures, preserving future ages, wrapped clocks, ID gates and index64 award/count aliasing. [Evidence](research/RUST_RECENT_AWARDS.md).

docs/PROVISIONAL_TODO.md

@@ -1296,3 +1296,6 @@ Research progress: RE-764 [report](research/QVM_RANKING_SETUP.md); full native/p
 
 
 Research progress: RE-765 [report](research/RUST_STAT_TOTALS.md); full native/platform/game scope remains open.
+
+
+Research progress: RE-766 [report](research/RUST_RECENT_AWARDS.md); full native/platform/game scope remains open.

docs/RESEARCH_LEDGER.md

@@ -1481,3 +1481,8 @@ Additional RE-763 regression: `cargo xtask test-group recipient-single` passes6
 ## 2026-10-21 — RE-765 Rust counter totals divisor and normalized ratio primitives
 
 Rust totals and normalized ratios match80 total,28 ratio and38 signed-divisor source fixtures while retaining20 slots. Focused `cargo xtask test-group gameplay` passes (25 Python tests); selected reports regenerate twice byte-identically, with storage, links and whitespace guards. New report: 32451 bytes. Full-suite validation is deferred to the tenth batch commit. Rust gameplay crate changed; focused gameplay regenerates eight parity contracts and scoped package tests. No workspace/full-suite run before commit ten.
+
+
+## 2026-10-21 — RE-766 Rust recent record awards timestamp gates and alias storage
+
+Rust recent-record awards match68 source fixtures, preserving future ages, wrapped clocks, ID gates and index64 award/count aliasing. Focused `cargo xtask test-group gameplay` passes (28 Python tests); selected reports regenerate twice byte-identically, with storage, links and whitespace guards. New report: 143080 bytes. Full-suite validation is deferred to the tenth batch commit. Rust gameplay crate changed; focused gameplay regenerates nine parity contracts and scoped package tests. Full workspace suite remains deferred to commit ten.

docs/REVERSE_ENGINEERING_TODO.md

@@ -1339,3 +1339,6 @@ Purpose: turn the supplied installation into an evidence-backed specification of
 
 
 - [x] RE-765 Rust counter totals divisor and normalized ratio primitives ([report](research/RUST_STAT_TOTALS.md)).
+
+
+- [x] RE-766 Rust recent record awards timestamp gates and alias storage ([report](research/RUST_RECENT_AWARDS.md)).

docs/research/README.md

@@ -891,3 +891,6 @@ The extension collector adds five focused tests for native tail calls, command-r
 
 
 [RE-765: Rust counter totals divisor and normalized ratio primitives](RUST_STAT_TOTALS.md).
+
+
+[RE-766: Rust recent record awards timestamp gates and alias storage](RUST_RECENT_AWARDS.md).

docs/research/RUST_RECENT_AWARDS.md

@@ -0,0 +1,7 @@
+# Rust recent record awards timestamp gates and alias storage
+
+RE-766. Reproduce with `python3 scripts/analyze_rust_recent_awards.py`; validate with `cargo xtask test-group gameplay`. See the [machine report](rust-recent-awards.json).
+
+Added typed65-row records,64-recipient scan, source signed/wrapping eligibility and returned log ID intents. Pair64[0] is the award counter rather than separate storage. Four Rust unit tests cover equality, future timestamps, count/counter wrap, empty/invalid gates and explicit unsupported offender indices. Log formatting, record lifetime ownership and native/platform parity remain open.
+
+No original executable/full VM/native world collision or rendering runs. Supplied callback/native responses and fixture domains remain explicit; complete macOS/Linux Rust/Bevy/Solari gameplay remains open.

docs/research/rust-health-impulse.json

@@ -2985,7 +2985,7 @@
       "exit_code": 2
     }
   ],
-  "rust_unit_tests": 34,
+  "rust_unit_tests": 38,
   "source_report": "docs/research/qvm-health-impulse.json",
   "source_report_sha256": "625fd8064004ea6dbdf398d51d0af844d9c635ff04c0a0790886dddb6ab81e71"
 }

scripts/analyze_rust_recent_awards.py

@@ -0,0 +1,13 @@
+#!/usr/bin/env python3
+"""Rust recent-award records and logging intent against source285227 fixtures."""
+import hashlib,json
+from pathlib import Path
+from rust_lifecycle_support import binary,result
+from analyze_qvm import write_json
+
+def main():
+    b=binary();path=Path('docs/research/qvm-recent-awards.json');data=path.read_bytes();rows=[]
+    for p in json.loads(data)['probes']:
+        a=p['input'];args=[a.get('mode',10),a['index'],a.get('count',40),a.get('age',30000),a.get('initial',7),a.get('now',40000),int(a.get('actor_client',True))];expected={'awards':[[c['arguments'][str(k)] for k in [12,16,20]] for c in p['requests']],'rows':[{k:r[k] for k in ['slot','awards','count']} for r in p['final'] if r['present']]};rows.append({'input':a,'initial':p['initial'],'source':expected,'rust':result(b,'award',args)})
+    write_json(Path('docs/research/rust-recent-awards.json'),{'source_report':str(path),'source_report_sha256':hashlib.sha256(data).hexdigest(),'probes':rows,'limits':'Rust numeric recent awards and log ID intents match68 source fixtures.65 rows support victim64; only64 recipients are scanned. Pair64[0] shares award/count storage. Unsupported offender indices explicitly reject; live lifetime ownership/log formatting/native/platform parity remain open.'})
+if __name__=='__main__':main()

scripts/test_rust_recent_awards.py

@@ -0,0 +1,13 @@
+import hashlib,json,unittest
+from pathlib import Path
+from test_qvm_recent_awards import awarded
+class RustRecentAwardTests(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):cls.r=json.loads(Path('docs/research/rust-recent-awards.json').read_text())
+    def test_exact_source_records_and_intents(self):
+        self.assertEqual(len(self.r['probes']),68)
+        for p in self.r['probes']:self.assertEqual(p['rust'],p['source'],p['input'])
+    def test_independent_gates_and_identifier_intent(self):
+        for p in self.r['probes']:self.assertEqual(p['rust']['awards'],[[j,2,p['input']['index']] for j in awarded(p)])
+    def test_source_identity(self):self.assertEqual(hashlib.sha256(Path(self.r['source_report']).read_bytes()).hexdigest(),self.r['source_report_sha256'])
+if __name__=='__main__':unittest.main()

xtask/checks.tsv

@@ -1303,3 +1303,13 @@ edge	crates/urt-gameplay/src/stat_totals.rs	scripts/analyze_rust_health_impulse.
 group	gameplay	scripts/analyze_rust_stat_totals.py
 report	scripts/analyze_rust_stat_totals.py	docs/research/rust-stat-totals.json
 edge	docs/research/rust-stat-totals.json	scripts/test_rust_stat_totals.py
+edge	Cargo.toml	scripts/analyze_rust_recent_awards.py
+edge	Cargo.lock	scripts/analyze_rust_recent_awards.py
+edge	crates/urt-gameplay/Cargo.toml	scripts/analyze_rust_recent_awards.py
+edge	crates/urt-gameplay/src/lib.rs	scripts/analyze_rust_recent_awards.py
+edge	crates/urt-gameplay/src/recent_awards.rs	scripts/analyze_rust_recent_awards.py
+edge	crates/urt-gameplay/src/bin/urt-lifecycle.rs	scripts/analyze_rust_recent_awards.py
+edge	crates/urt-gameplay/src/recent_awards.rs	scripts/analyze_rust_health_impulse.py
+group	gameplay	scripts/analyze_rust_recent_awards.py
+report	scripts/analyze_rust_recent_awards.py	docs/research/rust-recent-awards.json
+edge	docs/research/rust-recent-awards.json	scripts/test_rust_recent_awards.py