use system randomness by default unless overridden

src/Episode3/DeckState.cc

@@ -205,8 +205,8 @@ void DeckState::do_mulligan(bool is_nte) {
     size_t max = this->num_drawable_cards() - 5;
     uint8_t base_index = this->draw_index + 5;
     for (size_t z = 0; z < this->card_refs.size(); z++) {
-      uint8_t index1 = this->random_crypt->next() % max;
-      uint8_t index2 = this->random_crypt->next() % max;
+      uint8_t index1 = random_from_optional_crypt(this->opt_rand_crypt) % max;
+      uint8_t index2 = random_from_optional_crypt(this->opt_rand_crypt) % max;
       uint16_t temp_ref = this->card_refs[base_index + index1];
       this->card_refs[base_index + index1] = this->card_refs[base_index + index2];
       this->card_refs[base_index + index2] = temp_ref;
@@ -265,8 +265,8 @@ void DeckState::shuffle() {
       // instead swap each item with another random item (possibly itself) that
       // doesn't appear earlier than it in the array, but this is not what Sega
       // did.
-      uint8_t index1 = this->draw_index + this->random_crypt->next() % max;
-      uint8_t index2 = this->draw_index + this->random_crypt->next() % max;
+      uint8_t index1 = this->draw_index + random_from_optional_crypt(this->opt_rand_crypt) % max;
+      uint8_t index2 = this->draw_index + random_from_optional_crypt(this->opt_rand_crypt) % max;
       uint16_t temp_ref = this->card_refs[index1];
       this->card_refs[index1] = this->card_refs[index2];
       this->card_refs[index2] = temp_ref;

src/Episode3/DeckState.hh

@@ -57,13 +57,13 @@ public:
   DeckState(
       uint8_t client_id,
       const parray<CardIDT, 0x1F>& card_ids,
-      std::shared_ptr<PSOLFGEncryption> random_crypt)
+      std::shared_ptr<PSOLFGEncryption> opt_rand_crypt)
       : client_id(client_id),
         draw_index(1),
         card_ref_base(this->client_id << 8),
         shuffle_enabled(true),
         loop_enabled(true),
-        random_crypt(random_crypt) {
+        opt_rand_crypt(opt_rand_crypt) {
     for (size_t z = 0; z < card_ids.size(); z++) {
       auto& e = this->entries[z];
       e.card_id = card_ids[z];
@@ -112,7 +112,7 @@ private:
   parray<CardEntry, 31> entries;
   parray<uint16_t, 31> card_refs;
 
-  std::shared_ptr<PSOLFGEncryption> random_crypt;
+  std::shared_ptr<PSOLFGEncryption> opt_rand_crypt;
 };
 
 } // namespace Episode3

src/Episode3/PlayerState.cc

@@ -49,7 +49,7 @@ void PlayerState::init() {
     throw logic_error("replacing a player state object is not permitted");
   }
 
-  this->deck_state = make_shared<DeckState>(this->client_id, s->deck_entries[client_id]->card_ids, s->options.random_crypt);
+  this->deck_state = make_shared<DeckState>(this->client_id, s->deck_entries[client_id]->card_ids, s->options.opt_rand_crypt);
   if (s->map_and_rules->rules.disable_deck_shuffle) {
     this->deck_state->disable_shuffle();
   }

src/Episode3/Server.cc

@@ -99,10 +99,10 @@ void Server::init() {
   this->card_special = make_shared<CardSpecial>(this->shared_from_this());
 
   // Note: The original implementation calls the default PSOV2Encryption
-  // constructor for random_crypt, which just uses 0 as the seed. It then
+  // constructor for opt_rand_crypt, which just uses 0 as the seed. It then
   // re-seeds the generator later. We instead expect the caller to provide a
   // seeded generator, and we don't re-seed it at all.
-  // this->random_crypt = make_shared<PSOV2Encryption>(0);
+  // this->opt_rand_crypt = make_shared<PSOV2Encryption>(0);
 
   this->state_flags = make_shared<StateFlags>();
 
@@ -273,10 +273,15 @@ void Server::send_6xB4x46() const {
     G_ServerVersionStrings_Ep3_6xB4x46 cmd;
     cmd.version_signature.encode(VERSION_SIGNATURE, 1);
     cmd.date_str1.encode(format_time(this->options.card_index->definitions_mtime() * 1000000), 1);
-    string date_str2 = string_printf(
-        "Random:%08" PRIX32 "+%08" PRIX32,
-        this->options.random_crypt->seed(),
-        this->options.random_crypt->absolute_offset());
+    string date_str2;
+    if (this->options.opt_rand_crypt) {
+      date_str2 = string_printf(
+          "Random:%08" PRIX32 "+%08" PRIX32,
+          this->options.opt_rand_crypt->seed(),
+          this->options.opt_rand_crypt->absolute_offset());
+    } else {
+      date_str2 = "Random:<SYS>";
+    }
     if (this->last_chosen_map) {
       date_str2 += string_printf(" Map:%08" PRIX32, this->last_chosen_map->map_number);
     }
@@ -1080,14 +1085,14 @@ shared_ptr<const PlayerState> Server::get_player_state(uint8_t client_id) const
 
 uint32_t Server::get_random(uint32_t max) {
   // The original implementation was essentially:
-  // return (static_cast<double>(this->random_crypt->next() >> 16) / 65536.0) * max
-  // This is unnecessarily complicated, so we instead just do this:
-  return this->options.random_crypt->next() % max;
+  // return (static_cast<double>(this->opt_rand_crypt->next() >> 16) / 65536.0) * max
+  // This is unnecessarily complicated and imprecise, so we instead just do:
+  return random_from_optional_crypt(this->options.opt_rand_crypt) % max;
 }
 
 float Server::get_random_float_0_1() {
   // This lacks some precision, but matches the original implementation.
-  return (static_cast<double>(this->options.random_crypt->next() >> 16) / 65536.0);
+  return (static_cast<double>(random_from_optional_crypt(this->options.opt_rand_crypt) >> 16) / 65536.0);
 }
 
 uint32_t Server::get_round_num() const {
@@ -1544,8 +1549,8 @@ void Server::setup_and_start_battle() {
 
   this->setup_phase = SetupPhase::STARTER_ROLLS;
 
-  // Note: This is where original implementation re-seeds random_crypt (it uses
-  // time() as the seed value).
+  // Note: This is where original implementation re-seeds opt_rand_crypt (it
+  // uses time() as the seed value).
 
   for (size_t z = 0; z < 4; z++) {
     if (!this->check_presence_entry(z)) {

src/Episode3/Server.hh

@@ -71,7 +71,7 @@ public:
     std::shared_ptr<const CardIndex> card_index;
     std::shared_ptr<const MapIndex> map_index;
     uint32_t behavior_flags;
-    std::shared_ptr<PSOLFGEncryption> random_crypt;
+    std::shared_ptr<PSOLFGEncryption> opt_rand_crypt;
     std::shared_ptr<const Tournament> tournament;
     std::array<std::vector<uint16_t>, 5> trap_card_ids;