synaps 0.1.2

Terminal-native AI agent runtime — parallel orchestration, reactive subagents, MCP, autonomous supervision
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use crate::games::blackjack::{Card, Rank, Deck};

#[derive(Debug, Clone, PartialEq)]
pub enum WarPhase {
    Betting,
    Reveal,      // Show both cards
    War,         // Tie — go to war
    WarReveal,   // War cards revealed
    Result,
}

#[derive(Debug, Clone, PartialEq)]
pub enum WarOutcome {
    PlayerWin,
    DealerWin,
    TieGoToWar,
    PlayerWinsWar,
    DealerWinsWar,
}

pub struct WarGame {
    pub phase: WarPhase,
    pub deck: Deck,
    pub player_card: Option<Card>,
    pub dealer_card: Option<Card>,
    pub war_player: Option<Card>,
    pub war_dealer: Option<Card>,
    pub bet: u64,
    pub bet_input: String,
    pub outcome: Option<WarOutcome>,
    pub last_payout: i64,
    pub phase_timer: u64,
}

fn card_value(card: &Card) -> u8 {
    match card.rank {
        Rank::Ace => 14,
        Rank::King => 13,
        Rank::Queen => 12,
        Rank::Jack => 11,
        _ => card.rank.value(),
    }
}

impl WarGame {
    pub fn new() -> Self {
        Self {
            phase: WarPhase::Betting,
            deck: Deck::new_shuffled(),
            player_card: None,
            dealer_card: None,
            war_player: None,
            war_dealer: None,
            bet: 0,
            bet_input: String::new(),
            outcome: None,
            last_payout: 0,
            phase_timer: 0,
        }
    }

    pub fn deal(&mut self, bet: u64) {
        self.bet = bet;
        self.player_card = Some(self.deck.draw());
        self.dealer_card = Some(self.deck.draw());
        self.phase = WarPhase::Reveal;
        self.phase_timer = 0;
    }

    pub fn resolve_reveal(&mut self) {
        let pv = card_value(self.player_card.as_ref().unwrap());
        let dv = card_value(self.dealer_card.as_ref().unwrap());

        if pv > dv {
            self.outcome = Some(WarOutcome::PlayerWin);
            self.last_payout = self.bet as i64;
            self.phase = WarPhase::Result;
        } else if dv > pv {
            self.outcome = Some(WarOutcome::DealerWin);
            self.last_payout = -(self.bet as i64);
            self.phase = WarPhase::Result;
        } else {
            self.outcome = Some(WarOutcome::TieGoToWar);
            self.phase = WarPhase::War;
            self.phase_timer = 0;
        }
    }

    pub fn go_to_war(&mut self) {
        // Burn 3 cards, deal 1 each
        for _ in 0..3 { self.deck.draw(); }
        self.war_player = Some(self.deck.draw());
        for _ in 0..3 { self.deck.draw(); }
        self.war_dealer = Some(self.deck.draw());
        self.phase = WarPhase::WarReveal;
        self.phase_timer = 0;
    }

    pub fn resolve_war(&mut self) {
        let pv = card_value(self.war_player.as_ref().unwrap());
        let dv = card_value(self.war_dealer.as_ref().unwrap());

        if pv >= dv {
            // Player wins war — pays 1:1 on original bet
            self.outcome = Some(WarOutcome::PlayerWinsWar);
            self.last_payout = self.bet as i64;
        } else {
            self.outcome = Some(WarOutcome::DealerWinsWar);
            self.last_payout = -(self.bet as i64);
        }
        self.phase = WarPhase::Result;
    }

    pub fn new_hand(&mut self) {
        self.phase = WarPhase::Betting;
        self.player_card = None;
        self.dealer_card = None;
        self.war_player = None;
        self.war_dealer = None;
        self.bet = 0;
        self.bet_input.clear();
        self.outcome = None;
        self.last_payout = 0;
        self.phase_timer = 0;
    }
}