Merge pull request #56 from genonullfree/fix/miner-display

Fix/miner display

Author: genonullfree

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "idlecoin"
-version = "0.3.4"
+version = "0.3.5"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

Cargo.toml

@@ -0,0 +1,131 @@
+use crate::*;
+
+pub fn read_inputs(
+    connections: &Arc<Mutex<Vec<Connection>>>,
+    wallets: &Arc<Mutex<Vec<Wallet>>>,
+    msg: &mut Vec<String>,
+) {
+    let mut cons = connections.lock().unwrap();
+
+    for c in cons.iter_mut() {
+        let mut buf = [0; 1024];
+        let len = match c.stream.read(&mut buf) {
+            Ok(l) => l,
+            Err(_) => continue,
+        };
+
+        if len > 0 {
+            println!(
+                "> User: 0x{:016x} Miner 0x{:08x} sent: {:?} from: {:?}",
+                c.miner.wallet_id,
+                c.miner.miner_id,
+                &buf[..len],
+                c.stream
+            );
+        }
+
+        let mut new_boost = 0;
+        let mut new_boost_cost = 0u128;
+        let mut new_miners = 0;
+        let mut new_miners_cost = 0u128;
+
+        for i in buf[..len].iter() {
+            if *i == b'b' {
+                // Purchase boost
+                let mut wals = wallets.lock().unwrap();
+                for w in wals.iter_mut() {
+                    if w.id == c.miner.wallet_id {
+                        let cost = buy_boost(c, w);
+                        if cost > 0 {
+                            new_boost += 128;
+                            new_boost_cost += cost as u128;
+                        }
+                    }
+                }
+                drop(wals);
+            }
+            if *i == b'm' {
+                // Purchase miner licenses
+                let mut wals = wallets.lock().unwrap();
+                for w in wals.iter_mut() {
+                    if w.id == c.miner.wallet_id {
+                        let cost = buy_miner(c, w);
+                        if cost > 0 {
+                            new_miners += 1;
+                            new_miners_cost += cost as u128;
+                        }
+                    }
+                }
+                drop(wals);
+            }
+        }
+        let t: DateTime<Local> = Local::now();
+        if new_boost > 0 {
+            msg.insert(
+                0,
+                format!(
+                    " [{}] Miner 0x{:08x} bought {} boost seconds with {} idlecoin\n",
+                    t.format("%Y-%m-%d %H:%M:%S"),
+                    c.miner.miner_id,
+                    new_boost,
+                    new_boost_cost,
+                ),
+            );
+        }
+        if new_miners > 0 {
+            msg.insert(
+                0,
+                format!(
+                    " [{}] Wallet 0x{:016x} bought new miner license(s) with {} idlecoin\n",
+                    t.format("%Y-%m-%d %H:%M:%S"),
+                    c.miner.wallet_id,
+                    new_miners_cost
+                ),
+            );
+        }
+    }
+    drop(cons);
+}
+
+pub fn boost_cost(cps: u64) -> u64 {
+    let v = u64::BITS - cps.leading_zeros() - 1;
+    1u64.checked_shl(v).unwrap_or(0)
+}
+
+fn buy_boost(connection: &mut Connection, wallet: &mut Wallet) -> u64 {
+    if connection.miner.cps < 1024 {
+        connection
+            .updates
+            .push("You need at least 1024 Cps to be able to purchase boost\n".to_string());
+        return 0;
+    }
+    let cost = boost_cost(connection.miner.cps);
+    if wallet.idlecoin < cost && wallet.supercoin == 0 {
+        connection
+            .updates
+            .push("You do not have the funds to purchase boost\n".to_string());
+        return 0;
+    }
+    let boost = 128u64;
+    miner::sub_idlecoins(wallet, cost);
+    connection.miner.boost = connection.miner.boost.saturating_add(boost);
+
+    cost
+}
+
+fn buy_miner(connection: &mut Connection, mut wallet: &mut Wallet) -> u64 {
+    if wallet.max_miners >= 10 {
+        connection
+            .updates
+            .push("You cannot purchase any more miners\n".to_string());
+        return 0;
+    }
+
+    let cost = u64::MAX / (100000 >> (wallet.max_miners - 5));
+    if wallet.idlecoin > cost || wallet.supercoin > 0 {
+        miner::sub_idlecoins(wallet, cost);
+        wallet.max_miners += 1;
+    }
+
+    cost
+}

src/commands.rs

@@ -0,0 +1,64 @@
+use crate::*;
+
+pub fn load_stats(wallets: &Arc<Mutex<Vec<Wallet>>>) -> Result<(), Error> {
+    let mut j = String::new();
+
+    // Attempt to open and read the saved stats file
+    let mut file = match File::open(&SAVE) {
+        Ok(f) => f,
+        Err(_) => {
+            println!("No stats file found.");
+            return Ok(());
+        }
+    };
+
+    file.read_to_string(&mut j)?;
+
+    // Exit if file is empty
+    if j.is_empty() {
+        return Err(Error::new(ErrorKind::InvalidData, "No data to load"));
+    }
+
+    // Attempt to deserialize the json file data
+    println!("Loading stats...");
+    if let Ok(mut wallet) = serde_json::from_str(&j) {
+        // Update the wallets struct
+        let mut gens = wallets.lock().unwrap();
+        gens.append(&mut wallet);
+        drop(gens);
+        println!("Successfully loaded stats file {}", SAVE);
+    } else {
+        return Err(Error::new(
+            ErrorKind::InvalidData,
+            format!("Failed to load {}", SAVE),
+        ));
+    }
+
+    Ok(())
+}
+
+pub fn save_stats(wallets: Arc<Mutex<Vec<Wallet>>>) {
+    // Serialize the stats data to json
+    println!("Saving stats...");
+    let gens = wallets.lock().unwrap();
+    let j = serde_json::to_string_pretty(&gens.deref()).unwrap();
+    drop(gens);
+
+    // Open the stats file for writing
+    let mut file = match File::create(&SAVE) {
+        Ok(f) => f,
+        Err(_) => {
+            println!("Error opening {} for writing!", SAVE);
+            return;
+        }
+    };
+
+    // Write out the json stats data
+    let len = file.write(j.as_bytes()).unwrap();
+    if j.len() != len {
+        println!("Error writing save data to {}", SAVE);
+        return;
+    }
+
+    println!("Successfully saved data to {}", SAVE);
+}