Display how many knights each player has played if that number is non-zero

Author: ashn-dot-dev

client.sunder

@@ -1407,26 +1407,31 @@ func client_update(cstate: *client_state, sender: *message_sender[[client_messag
             var victory_points: sint = uninit;
             var resources: sint = uninit;
             var dev_cards: sint = uninit;
+            var knights_played: sint = uninit;
             switch player {
             ::player::RED {
                 victory_points = cstate.*.r.victory_points;
                 resources = cstate.*.r.resources;
                 dev_cards = cstate.*.r.dev_cards;
+                knights_played = cstate.*.r.knights_played;
             }
             ::player::BLUE {
                 victory_points = cstate.*.b.victory_points;
                 resources = cstate.*.b.resources;
                 dev_cards = cstate.*.b.dev_cards;
+                knights_played = cstate.*.b.knights_played;
             }
             ::player::WHITE {
                 victory_points = cstate.*.w.victory_points;
                 resources = cstate.*.w.resources;
                 dev_cards = cstate.*.w.dev_cards;
+                knights_played = cstate.*.w.knights_played;
             }
             ::player::ORANGE {
                 victory_points = cstate.*.o.victory_points;
                 resources = cstate.*.o.resources;
                 dev_cards = cstate.*.o.dev_cards;
+                knights_played = cstate.*.o.knights_played;
             }
             }
 
@@ -1472,6 +1477,14 @@ func client_update(cstate: *client_state, sender: *message_sender[[client_messag
                 (:[]std::formatter)[
                     std::formatter::init[[sint]](&dev_cards)]);
             defer s.fini();
+            if knights_played != 0 {
+                var w = std::writer::init[[typeof(s)]](&s);
+                std::print_format(
+                    w,
+                    " ({} knights played)",
+                    (:[]std::formatter)[
+                        std::formatter::init[[sint]](&knights_played)]);
+            }
             cstate.*.ui.text(s.data());
 
             if cstate.*.player.is_value() and cstate.*.player.value() == player {

server.sunder

@@ -2148,6 +2148,7 @@ func server_update(sstate: *server_state) void {
         .victory_points = sstate.*.public_victory_points(player::RED),
         .resources = sstate.*.r_info.resource_count(),
         .dev_cards = sstate.*.r_info.unused_dev_card_count(),
+        .knights_played = sstate.*.r_info.knights_played_count(),
         .discarded = sstate.*.r_discarded,
         .trade_submitted = sstate.*.r_trade_submitted,
     };
@@ -2157,6 +2158,7 @@ func server_update(sstate: *server_state) void {
         .victory_points = sstate.*.public_victory_points(player::BLUE),
         .resources = sstate.*.b_info.resource_count(),
         .dev_cards = sstate.*.b_info.unused_dev_card_count(),
+        .knights_played = sstate.*.b_info.knights_played_count(),
         .discarded = sstate.*.b_discarded,
         .trade_submitted = sstate.*.b_trade_submitted,
     };
@@ -2166,6 +2168,7 @@ func server_update(sstate: *server_state) void {
         .victory_points = sstate.*.public_victory_points(player::WHITE),
         .resources = sstate.*.w_info.resource_count(),
         .dev_cards = sstate.*.w_info.unused_dev_card_count(),
+        .knights_played = sstate.*.w_info.knights_played_count(),
         .discarded = sstate.*.w_discarded,
         .trade_submitted = sstate.*.w_trade_submitted,
     };
@@ -2175,6 +2178,7 @@ func server_update(sstate: *server_state) void {
         .victory_points = sstate.*.public_victory_points(player::ORANGE),
         .resources = sstate.*.o_info.resource_count(),
         .dev_cards = sstate.*.o_info.unused_dev_card_count(),
+        .knights_played = sstate.*.o_info.knights_played_count(),
         .discarded = sstate.*.o_discarded,
         .trade_submitted = sstate.*.o_trade_submitted,
     };

shared.sunder

@@ -1610,6 +1610,14 @@ struct hidden_player_info {
         }
         return count;
     }
+
+    func knights_played_count(self: *hidden_player_info) sint {
+        var count: sint = 0;
+        for i in self.*.dev_card_count {
+            count += (:sint)(self.*.dev_card_array[i].kind == dev_card::KNIGHT and self.*.dev_card_array[i].used);
+        }
+        return count;
+    }
 }
 
 struct public_player_info {
@@ -1618,6 +1626,7 @@ struct public_player_info {
     var victory_points: sint;
     var resources: sint;
     var dev_cards: sint;
+    var knights_played: sint;
     var discarded: bool;
     var trade_submitted: bool;
 
@@ -1628,6 +1637,7 @@ struct public_player_info {
         self.victory_points = xstr_to_int[[sint]](value.*.map_xlookup_str("victory-points").*.str());
         self.resources = xstr_to_int[[sint]](value.*.map_xlookup_str("resources").*.str());
         self.dev_cards = xstr_to_int[[sint]](value.*.map_xlookup_str("dev-cards").*.str());
+        self.knights_played = xstr_to_int[[sint]](value.*.map_xlookup_str("knights-played").*.str());
         self.discarded = xstr_to_bool(value.*.map_xlookup_str("discarded").*.str());
         self.trade_submitted = xstr_to_bool(value.*.map_xlookup_str("trade-submitted").*.str());
         return self;
@@ -1640,6 +1650,7 @@ struct public_player_info {
         out.map_insert_str("victory-points", int_to_bubby[[sint]](self.*.victory_points));
         out.map_insert_str("resources", int_to_bubby[[sint]](self.*.resources));
         out.map_insert_str("dev-cards", int_to_bubby[[sint]](self.*.dev_cards));
+        out.map_insert_str("knights-played", int_to_bubby[[sint]](self.*.knights_played));
         out.map_insert_str("discarded", bool_to_bubby(self.*.discarded));
         out.map_insert_str("trade-submitted", bool_to_bubby(self.*.trade_submitted));
         return out;