apitest/at-currency.rs

   1 // Copyright 2020-2021 Ian Jackson and contributors to Otter
   2 // SPDX-License-Identifier: AGPL-3.0-or-later
   3 // There is NO WARRANTY.
   4
   5 use crate::*;
   6
   7 type Ctx = UsualCtx;
   8
   9 impl Session {
  10   #[throws(Explode)]
  11   fn move_money<PI:Idx>(&mut self,
  12                         a_pieces: &mut Pieces<PI>, piece: PI,
  13                         qty: i32, z: &str, pos: Pos) {
  14     self.api_piece_op_single(PuSynch((&mut *a_pieces, piece)).id(), (
  15       "multigrab", json!({ "n": qty, 'z': z })
  16     ))?;
  17
  18     self.api_piece(GH::Ungrab, PuSynch((&mut *a_pieces, piece)), pos)?;
  19   }
  20 }
  21
  22 impl Ctx {
  23   #[throws(Explode)]
  24   fn multigrab(&mut self) {
  25     let mut alice = self.connect_player(&self.alice)?;
  26     let mut a_pieces = alice.pieces::<PIA>()?;
  27
  28     let bank = a_pieces.find_by_desc_glob("*400ƒ*");
  29
  30     let pile_pos = PosC::new(40,20);
  31     let temp_pos = PosC::new(40,10);
  32
  33     alice.api_piece_op_single(PuSynch((&mut a_pieces, bank)).id(), (
  34       "multigrab", json!({ "n": 50, 'z': "q000000000" })
  35     ))?;
  36     alice.synchu(&mut a_pieces)?;
  37
  38     let pile = bank;
  39     let bank = a_pieces.find_by_desc_glob("* 350ƒ*");
  40     a_pieces[pile].assert_desc_contains(" 50ƒ");
  41
  42     alice.api_piece(GH::Ungrab, PuSynch((&mut a_pieces, pile)), pile_pos)?;
  43     alice.synchu(&mut a_pieces)?;
  44
  45     alice.move_money(&mut a_pieces, bank, 13, "t000000000", temp_pos)?;
  46     let moved = bank;
  47     alice.synchu(&mut a_pieces)?;
  48     let bank = a_pieces.find_by_desc_glob("* 337ƒ*");
  49     a_pieces[moved].assert_desc_contains(" 13ƒ");
  50
  51     alice.api_piece(GH::With, PuSynch((&mut a_pieces, moved)), pile_pos)?;
  52     alice.synchu(&mut a_pieces)?;
  53     assert!(a_pieces[moved].info.is_null());
  54     a_pieces[pile].assert_desc_contains(" 63ƒ");
  55
  56     // This saves us some complaints
  57     let _ = moved;
  58     let _ = bank;
  59     let _ = pile;
  60   }
  61
  62   #[throws(Explode)]
  63   fn occult(&mut self) {
  64     self.clear_reset_to_demo()?;
  65
  66     let mut alice = self.connect_player(&self.alice)?;
  67     let mut a_pieces = alice.pieces::<PIA>()?;
  68
  69     let mut bob = self.connect_player(&self.bob)?;
  70
  71     let hand = a_pieces.find_by_desc_glob(otter::hand::UNCLAIMED_HAND_DESC);
  72     alice.api_piece(GH::With, PuSynch(&mut (&mut a_pieces, hand)),
  73                     ("k", json!({ "opname": "claim",
  74                                    "wrc": WRC::Unpredictable })))?;
  75     let hand_pos = a_pieces[hand].pos;
  76
  77     alice.synchu(&mut a_pieces)?;
  78
  79     let bank = a_pieces.find_by_desc_glob("*400ƒ*");
  80
  81     alice.move_money(&mut a_pieces, bank, 399, "u000000000", hand_pos)?;
  82     alice.synchu(&mut a_pieces)?;
  83     // old bank has 1f, current piece has 399
  84
  85     let div1_pos = (hand_pos + PosC::new(-30,-5))?;
  86     alice.move_money(&mut a_pieces, bank, 99, "u010000000", div1_pos)?;
  87     // in hand has 300, current piece, aside, has 99
  88
  89     alice.move_money(&mut a_pieces, bank, 9, "u020000000", hand_pos)?;
  90     alice.synchu(&mut a_pieces)?;
  91     // aside has 90, in hand has 9, original hand pos has 309
  92
  93     let expected = [399];
  94     let expected = expected.into_iter()
  95       .map(|s| s.to_string())
  96       .chain(iter::once("?".to_string()))
  97       .collect_vec();
  98
  99     let mut qtys = vec![];
 100     bob.synchx::<PIB,_>(None, None, |_session, gen, _k, v| v.tree_walk(|k,v| {
 101       if let Some(s) = v.as_str() {
 102         for (_, qty) in regex_captures!(r#"([0-9.?]*)ƒ"#, s) {
 103           dbg!(gen, qty, k, s);
 104           qtys.push(qty.to_string());
 105 //          assert!(expected.iter().map(|s| &**s).contains(&qty));
 106         }
 107       }
 108       Ok::<_,Void>(())
 109     }).void_unwrap())?;
 110
 111     for exp in expected {
 112       assert!(qtys.contains(&exp), "{:?}", exp);
 113     }
 114
 115     let _ = &mut bob;
 116     let _ = bob;
 117   }
 118 }
 119
 120 #[throws(Explode)]
 121 fn tests(mut c: Ctx) {
 122   test!(c, "multigrab",                     c.multigrab()              ?);
 123   test!(c, "occult",                        c.occult()                 ?);
 124 }
 125
 126 #[throws(Explode)]
 127 pub fn main() {
 128   tests(Ctx::setup()?)?;
 129 }