Save 8710 bytes replacing rand crate with custom Pcg32 implementation

src/rs/server/src/handleget.rs

@@ -446,15 +446,12 @@ async fn handle_get_core(
 			return response::Builder::new().status(503).body(Bytes::new());
 		}
 	} else if path.starts_with("/speed/") {
-		if let Ok(seed) = path["/speed/".len()..].parse() {
-			use rand::{Rng, SeedableRng};
-			use rand_pcg::Pcg32;
-
-			let mut rng = Pcg32::seed_from_u64(seed);
+		if let Ok(seed) = path["/speed/".len()..].parse::<u32>() {
+			let rng = etg::rng::Pcg32::from(seed);
 			let mut eles = [false; 12];
 			let mut codes = [0i16; 84];
-			for i in 0..12 {
-				let mut ele = rng.gen_range(0..12 - i);
+			for i in 0..12usize {
+				let mut ele = rng.upto(12 - i as u32);
 				for idx in 0..12 {
 					if !eles[idx] {
 						if ele == 0 {
@@ -463,7 +460,7 @@ async fn handle_get_core(
 							for j in 0..7 {
 								let ij = i * 7 + j;
 								codes[ij] = card::OpenSet
-									.random_card(&mut rng, false, |card| {
+									.random_card(&rng, false, |card| {
 										card.element == ele
 											&& (card.flag & etg::game::Flag::pillar) == 0
 											&& !codes[i * 7..ij].iter().any(|&code| code == card.code)
@@ -484,7 +481,7 @@ async fn handle_get_core(
 				deck.extend(&encode_code(code));
 			}
 			deck.extend(&b"01"[..]);
-			deck.extend(&encode_code(rng.gen_range(9010..9022)));
+			deck.extend(&encode_code(9010 + rng.upto(12) as i16));
 			PlainResponse {
 				cache: CacheControl::NoCache,
 				kind: ContentType::ImageSvgXml,

src/rs/server/src/handlews.rs

@@ -1362,13 +1362,13 @@ pub async fn handle_ws(
 									userdata.ostreakday2 = today;
 									userdata.oracle = today;
 									let card = {
-										let mut rng = rand::thread_rng();
-										let ocardnymph = (rng.next_u32() & 31) == 0;
-										let Some(card) = etg::card::OpenSet.random_card(&mut rng, false, |card| {
+										let rng = etg::rng::Pcg32::from(rand::thread_rng().next_u32());
+										let ocardnymph = (rng.next32() & 31) == 0;
+										let Some(card) = etg::card::OpenSet.random_card(&rng, false, |card| {
 											(card.rarity != 4) ^ ocardnymph && (card.flag & etg::game::Flag::pillar) == 0
 										}) else { continue };
-										userdata.dailymage = rng.gen_range(0..MAGE_COUNT);
-										userdata.dailydg = rng.gen_range(0..DG_COUNT);
+										userdata.dailymage = rng.upto(MAGE_COUNT as u32) as u8;
+										userdata.dailydg = rng.upto(DG_COUNT as u32) as u8;
 										card
 									};
 									let ccode =
@@ -1568,7 +1568,7 @@ pub async fn handle_ws(
 								if bound || userdata.gold >= cost {
 									let mut newcards: Cardpool = Default::default();
 									let mut rarity: usize = 1;
-									let mut rng = rand::thread_rng();
+									let rng = etg::rng::Pcg32::from(rand::thread_rng().next_u32());
 									for i in 0..amount {
 										while rarity - 1 < rares.len() && i == rares[rarity - 1] * bulk as u16 {
 											rarity += 1;
@@ -1577,15 +1577,15 @@ pub async fn handle_ws(
 											etg::etg::NymphList[if element > 0 && element < 13 {
 												element as usize
 											} else {
-												rng.gen_range(1..13)
+												1 + rng.upto(13) as usize
 											}]
 										} else {
-											let notfromele = rng.gen_range(0..3) == 0;
+											let notfromele = rng.upto(3) == 0;
 											let bumprarity =
-												rarity + rng.gen_bool(bumprate) as usize;
+												rarity + ((rng.next32() as f64 / u32::MAX as f64) < bumprate) as usize;
 											if (element > 0 || bumprarity < 3) && element < 13 {
 												etg::card::OpenSet.random_card(
-													&mut rng,
+													&rng,
 													false,
 													|card| {
 														(card.element == element as i8)
@@ -1595,7 +1595,7 @@ pub async fn handle_ws(
 												)
 											} else {
 												etg::card::OpenSet.random_card(
-													&mut rng,
+													&rng,
 													false,
 													|card| card.rarity as usize == bumprarity,
 												)

src/rs/server/src/json.rs

@@ -469,7 +469,7 @@ pub enum WsResponse<'a> {
 	},
 	legacyboard {
 		top: &'a [(&'a str, &'a str, i32)],
-	}
+	},
 }
 
 #[derive(Serialize, Clone)]

src/rs/server/src/users.rs

@@ -3,7 +3,10 @@ use std::num::NonZeroUsize;
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
 use std::sync::Arc;
 
-use bb8_postgres::tokio_postgres::{types::{Json, FromSql, ToSql}, Client, GenericClient};
+use bb8_postgres::tokio_postgres::{
+	types::{FromSql, Json, ToSql},
+	Client, GenericClient,
+};
 use ring::constant_time::verify_slices_are_equal;
 use ring::pbkdf2;
 use serde::{Deserialize, Serialize};
@@ -216,7 +219,6 @@ impl Users {
 						Ok(Json(userdata)) => legacy.insert(name, userdata),
 						Err(err) => panic!("Invalid json for legacy {} {} {}", userid, name, err),
 					};
-
 				}
 			}
 			Some((data, legacy))

src/rs/src/card.rs

@@ -11,6 +11,7 @@ use crate::etg;
 pub use crate::game::CardSet;
 use crate::game::{Flag, Kind, Stat};
 pub use crate::generated::*;
+use crate::rng::Pcg32;
 use crate::skill::{Event, Skill};
 
 #[derive(Clone, Copy)]
@@ -66,14 +67,11 @@ impl Cards {
 		}
 	}
 
-	pub fn random_card<Ffilt, R>(&self, rng: &mut R, upped: bool, ffilt: Ffilt) -> Option<&'static Card>
+	pub fn random_card<Ffilt>(&self, rng: &Pcg32, upped: bool, ffilt: Ffilt) -> Option<&'static Card>
 	where
 		Ffilt: Fn(&'static Card) -> bool,
-		R: rand::Rng,
 	{
-		use rand::seq::IteratorRandom;
-
-		self.filter(upped).iter().filter(|c| (c.flag & Flag::token) == 0 && ffilt(c)).choose(rng)
+		rng.choose_iter(self.filter(upped).iter().filter(|c| (c.flag & Flag::token) == 0 && ffilt(c)))
 	}
 }
 
@@ -224,13 +222,11 @@ pub fn code_cmp_core(cards: &'static Cards, x: i16, y: i16) -> Ordering {
 
 #[cfg(target_arch = "wasm32")]
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen)]
-pub fn original_oracle(seed: i32) -> i16 {
-	use rand::{Rng, SeedableRng};
-	use rand_pcg::Pcg32;
-	let mut rng = Pcg32::seed_from_u64(seed as u64);
-	let nymph = rng.gen_range(0..100) < 3;
+pub fn original_oracle(seed: u32) -> i16 {
+	let mut rng = Pcg32::from(seed);
+	let nymph = rng.upto(100) < 3;
 	OrigSet
-		.random_card(&mut rng, false, |c| {
+		.random_card(&rng, false, |c| {
 			c.code != v_Relic as i16
 				&& !(c.code >= v_MarkofEntropy as i16 && c.code <= v_MarkofAether as i16)
 				&& !c.free() && nymph == etg::NymphList.contains(&(c.code + 4000))

src/rs/src/deckgen.rs

@@ -3,9 +3,6 @@
 use alloc::vec::Vec;
 use core::cell::RefCell;
 
-use rand::{Rng, SeedableRng};
-use rand_pcg::Pcg32;
-
 const PREC: i16 = 12;
 
 #[cfg(target_arch = "wasm32")]
@@ -14,18 +11,19 @@ use wasm_bindgen::prelude::*;
 use crate::card::{self, AsUpped, Card, Cards};
 use crate::etg;
 use crate::game::{Flag, Kind};
+use crate::rng::Pcg32;
 use crate::skill::{Event, Skill};
 
 #[cfg(target_arch = "wasm32")]
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen)]
-pub fn deckgen_duo(e1: i8, e2: i8, uprate: u8, markpower: i16, maxrarity: i32, seed: i32) -> Vec<i16> {
-	let mut rng = Pcg32::seed_from_u64(seed as u64);
-	let mut build = Builder::new(e2 as i16, uprate, markpower, &mut rng);
+pub fn deckgen_duo(e1: i8, e2: i8, uprate: u8, markpower: i16, maxrarity: i32, seed: u32) -> Vec<i16> {
+	let mut rng = Pcg32::from(seed);
+	let mut build = Builder::new(e2 as i16, uprate, markpower, &rng);
 	for j in [false, true] {
 		let ele = if j { e2 } else { e1 };
 		for i in 0..(if j { 9 } else { 15 }) {
-			let upped = rng.gen_range(0..100) < uprate;
-			if let Some(card) = card::OpenSet.random_card(&mut rng, upped, |card| {
+			let upped = rng.upto(100) < uprate as u32;
+			if let Some(card) = card::OpenSet.random_card(&rng, upped, |card| {
 				card.element == ele
 					&& (card.flag & Flag::pillar) == 0
 					&& card.rarity as i32 <= maxrarity
@@ -47,28 +45,28 @@ pub fn deckgen_duo(e1: i8, e2: i8, uprate: u8, markpower: i16, maxrarity: i32, s
 
 #[cfg(target_arch = "wasm32")]
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen)]
-pub fn deckgen_bow(uprate: u8, markpower: i16, maxrarity: i32, seed: i32) -> Vec<i16> {
-	let mut rng = Pcg32::seed_from_u64(seed as u64);
+pub fn deckgen_bow(uprate: u8, markpower: i16, maxrarity: i32, seed: u32) -> Vec<i16> {
+	let mut rng = Pcg32::from(seed);
 	let mut build: Builder;
-	if rng.gen_range(0..200) < uprate {
-		build = Builder::new(etg::Entropy, uprate, markpower, &mut rng);
-		for _ in 0..rng.gen_range(4..=6) {
+	if rng.upto(200) < uprate as u32 {
+		build = Builder::new(etg::Entropy, uprate, markpower, &rng);
+		for _ in 0..4 + rng.upto(3) {
 			build.add_card(AsUpped(card::Nova, true));
 		}
 	} else {
-		build = Builder::new(etg::Chroma, uprate, markpower, &mut rng);
-		for _ in 0..rng.gen_range(2..=6) {
+		build = Builder::new(etg::Chroma, uprate, markpower, &rng);
+		for _ in 0..2 + rng.upto(5) {
 			build.add_card(card::Nova);
 		}
-		for _ in 0..rng.gen_range(0..=2) {
+		for _ in 0..rng.upto(3) {
 			build.add_card(card::ChromaticButterfly);
 		}
 	}
 	while build.deck.len() < 30 {
 		for ele in 1..=12 {
-			for i in 0..=rng.gen_range(1..=4) {
-				let upped = rng.gen_range(0..100) < uprate;
-				if let Some(card) = card::OpenSet.random_card(&mut rng, upped, |card| {
+			for i in 0..=1 + (rng.next32() & 3) {
+				let upped = (rng.upto(100) as u8) < uprate;
+				if let Some(card) = card::OpenSet.random_card(&rng, upped, |card| {
 					card.element == ele
 						&& (card.flag & Flag::pillar) == 0
 						&& card.cost < 7 && card.rarity as i32 <= maxrarity
@@ -99,15 +97,15 @@ pub fn deckgen_bow(uprate: u8, markpower: i16, maxrarity: i32, seed: i32) -> Vec
 
 #[cfg(target_arch = "wasm32")]
 #[cfg_attr(target_arch = "wasm32", wasm_bindgen)]
-pub fn deckgen_ai4(e1: i8, e2: i8, seed: i32) -> Vec<i16> {
-	let mut rng = Pcg32::seed_from_u64(seed as u64);
+pub fn deckgen_ai4(e1: i8, e2: i8, seed: u32) -> Vec<i16> {
+	let mut rng = Pcg32::from(seed);
 	let mut deck = Vec::with_capacity(65);
 	for i in 0..24 {
-		let upped = rng.gen_range(0..100) < 30;
+		let upped = rng.upto(100) < 30;
 		deck.push(etg::PillarList[if i < 4 { 0 } else { e1 as usize }] - if upped { 2000 } else { 4000 });
 	}
 	for i in 0..40 {
-		let upped = rng.gen_range(0..100) < 30;
+		let upped = rng.upto(100) < 30;
 		let e = if i < 30 { e1 } else { e2 };
 		if let Some(card) = card::OrigSet.random_card(&mut rng, upped, |card| {
 			card.element == e
@@ -321,11 +319,11 @@ struct Builder {
 	pub anyweapon: u8,
 	pub ecost: [i16; 13],
 	pub uprate: u8,
-	pub rng: RefCell<Pcg32>,
+	pub rng: Pcg32,
 }
 
 impl Builder {
-	fn new(mark: i16, uprate: u8, markpower: i16, rng: &mut Pcg32) -> Builder {
+	fn new(mark: i16, uprate: u8, markpower: i16, rng: &Pcg32) -> Builder {
 		let mut ecost = [0; 13];
 		ecost[mark as usize] = markpower * (PREC * -8);
 		Builder {
@@ -335,7 +333,7 @@ impl Builder {
 			anyweapon: 0,
 			ecost: [0; 13],
 			uprate,
-			rng: RefCell::new(Pcg32::from_rng(rng).unwrap()),
+			rng: Pcg32::from(rng.next32()),
 		}
 	}
 
@@ -470,7 +468,7 @@ impl Builder {
 
 	fn up_code(&self, code: i16) -> i16 {
 		if self.uprate > 0 {
-			card::AsUpped(code, self.rng.borrow_mut().gen_range(0..100) < self.uprate)
+			card::AsUpped(code, (self.rng.upto(100) as u8) < self.uprate)
 		} else {
 			code
 		}