Merge pull request #75 from genonullfree/feature/buy-max

Feature/buy max

Author: genonullfree

Cargo.lock

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

Cargo.toml

@@ -13,12 +13,7 @@ This is an idle game where the point is to open a netcat connection to the serve
 
 The game has evolved to become semi-interactive, as there is now an element of purchasing upgrades to improve the performance of your miners, but this is entirely optional.
 
-## Use
-
-To start, run the `idlecoin` server:
-```rust
-cargo run --release
-```
+## Start Client Miner
 
 To join a server, use `netcat` or `telnet` to connect to the server:
 ```bash
@@ -28,9 +23,16 @@ nc 127.0.0.1 7654
 telnet localhost 7654
 ```
 
+## Start Server
+
+To start, run the `idlecoin` server:
+```rust
+cargo run --release
+```
+
 The stats are written out to a file `.idlecoin` in the working directory of the server upon exit. On start, `idlecoin` will attempt to open `.idlecoin` and ingest the stats file to allow loading of previous stats. The stats file will currently autosave every 5 minutes.
 
-## Output
+## Client Output
 
 ```
 [007] Wallet 0x9d75d7d276240c38 Miner Licenses: 5 Chronocoin: 8850 Randocoin: 208 Coins: 0:24436823427358 Total Cps: 10
@@ -103,9 +105,9 @@ These events are newest on top, and only the most recent 5 are displayed.
 
 These events can be a mix of users purchasing upgrades for their miners or special random events that can happen:
 
-1. Gain 10% CPS -- 0.01% chance
-1. Gain 1 Level -- 0.02% chance
-1. Lose 1 Level -- 0.01% chance
+1. Gain 10% CPS -- 0.001% chance
+1. Gain 1 Level -- 0.002% chance
+1. Lose 1 Level -- 0.001% chance
 1. IRS auditing -- 0.00000006430041152263% chance
 
 ### Purchasing Upgrades

README.md

@@ -1,5 +1,6 @@
 use crate::*;
 use std::collections::HashMap;
+use std::ops::AddAssign;
 
 #[derive(PartialEq, Eq, Hash)]
 enum PurchaseType {
@@ -14,6 +15,21 @@ struct Purchase {
     cost: u128,
 }
 
+impl Purchase {
+    fn new() -> Self {
+        Purchase { bought: 0, cost: 0 }
+    }
+}
+
+impl AddAssign for Purchase {
+    fn add_assign(&mut self, other: Self) {
+        *self = Self {
+            bought: self.bought + other.bought,
+            cost: self.cost + other.cost,
+        };
+    }
+}
+
 pub fn read_inputs(
     connections: &Arc<Mutex<Vec<Connection>>>,
     wallets: &Arc<Mutex<Vec<Wallet>>>,
@@ -46,54 +62,51 @@ pub fn read_inputs(
                         let new = match *i {
                             b'b' => {
                                 // Purchase boost
-                                let cost = match buy_boost(c, w) {
-                                    Ok(c) => c,
+                                match buy_boost(c, w) {
+                                    Ok(c) => Some(c),
                                     Err(e) => {
                                         if !c.updates.iter().any(|u| *u == e.to_string()) {
                                             c.updates.push(e.to_string());
                                         }
                                         continue;
                                     }
-                                };
-                                let new = Purchase {
-                                    bought: 128,
-                                    cost: cost as u128,
-                                };
-                                Some((PurchaseType::Boost, new))
+                                }
+                            }
+                            b'B' => {
+                                // Purchase MAX boost
+                                buy_max_boost(c, w)
                             }
                             b'm' => {
                                 // Purchase miner licenses
-                                let cost = match buy_miner(w) {
-                                    Ok(c) => c,
+                                match buy_miner(w) {
+                                    Ok(c) => Some(c),
                                     Err(e) => {
                                         if !c.updates.iter().any(|u| *u == e.to_string()) {
                                             c.updates.push(e.to_string());
                                         }
                                         continue;
                                     }
-                                };
-                                let new = Purchase {
-                                    bought: 1,
-                                    cost: cost as u128,
-                                };
-                                Some((PurchaseType::Miner, new))
+                                }
+                            }
+                            b'M' => {
+                                // Purchase MAX miners
+                                buy_max_miner(w)
                             }
                             b'c' => {
                                 // Purchase time travel
-                                let cost = match buy_time(c, w) {
-                                    Ok(c) => c,
+                                match buy_time(c, w) {
+                                    Ok(c) => Some(c),
                                     Err(e) => {
                                         if !c.updates.iter().any(|u| *u == e.to_string()) {
                                             c.updates.push(e.to_string());
                                         }
                                         continue;
                                     }
-                                };
-                                let new = Purchase {
-                                    bought: 1,
-                                    cost: cost as u128,
-                                };
-                                Some((PurchaseType::Chrono, new))
+                                }
+                            }
+                            b'C' => {
+                                // Purchase MAX time travel
+                                buy_max_time(c, w)
                             }
                             _ => None,
                         };
@@ -108,6 +121,12 @@ pub fn read_inputs(
         // Purchase notification updates
         for (k, p) in upgrades.iter() {
             let t: DateTime<Local> = Local::now();
+
+            // Skip if nothing was purchased
+            if p.cost == 0 {
+                continue;
+            }
+
             match k {
                 PurchaseType::Boost => msg.insert(
                     0,
@@ -152,8 +171,7 @@ fn update_upgrade_list(
         Some(n) => *n,
         None => Purchase { bought: 0, cost: 0 },
     };
-    node.bought += p.bought;
-    node.cost += p.cost;
+    node += p;
     map.insert(p_type, node);
 }
 
@@ -162,14 +180,23 @@ pub fn boost_cost(cps: u64) -> u64 {
     1u64.checked_shl(v).unwrap_or(0)
 }
 
-fn buy_boost(connection: &mut Connection, wallet: &mut Wallet) -> Result<u64, Error> {
+pub fn boost_max_cost(cps: u64, boost: u64) -> u64 {
+    let cost = boost_cost(cps);
+    let left = (u16::MAX as u64 - boost) / 128;
+    cost * left
+}
+
+fn buy_boost(
+    connection: &mut Connection,
+    wallet: &mut Wallet,
+) -> Result<(PurchaseType, Purchase), Error> {
     if connection.miner.cps < 1024 {
         return Err(Error::new(
             ErrorKind::InvalidData,
             "You need at least 1024 Cps to be able to purchase boost\n",
         ));
     }
-    if connection.miner.boost > u16::MAX as u64 {
+    if connection.miner.boost >= u16::MAX as u64 - 128 {
         return Err(Error::new(
             ErrorKind::InvalidData,
             "You cannot purchase any more boost right now\n",
@@ -182,9 +209,35 @@ fn buy_boost(connection: &mut Connection, wallet: &mut Wallet) -> Result<u64, Er
             format!("You need {} idlecoins to purchase boost\n", cost),
         ));
     }
-    connection.miner.boost = connection.miner.boost.saturating_add(128);
+    let bought: usize = 128;
+    connection.miner.boost = connection.miner.boost.saturating_add(bought as u64);
+    if connection.miner.boost > u16::MAX as u64 {
+        connection.miner.boost = u16::MAX as u64;
+    }
 
-    Ok(cost)
+    Ok((
+        PurchaseType::Boost,
+        Purchase {
+            bought,
+            cost: cost as u128,
+        },
+    ))
+}
+
+fn buy_max_boost(
+    connection: &mut Connection,
+    wallet: &mut Wallet,
+) -> Option<(PurchaseType, Purchase)> {
+    let mut totals = Purchase::new();
+
+    loop {
+        let (_, p) = match buy_boost(connection, wallet) {
+            Ok(b) => b,
+            Err(_) => return Some((PurchaseType::Boost, totals)),
+        };
+
+        totals += p;
+    }
 }
 
 pub fn miner_cost(max_miners: u64) -> u64 {
@@ -195,7 +248,21 @@ pub fn miner_cost(max_miners: u64) -> u64 {
     }
 }
 
-fn buy_miner(mut wallet: &mut Wallet) -> Result<u64, Error> {
+pub fn miner_max_cost(max_miners: u64) -> u128 {
+    let mut max = max_miners;
+    let mut cost = 0u128;
+    loop {
+        if max <= ABS_MAX_MINERS {
+            cost += miner_cost(max) as u128;
+            max += 1;
+        } else {
+            break;
+        }
+    }
+    cost
+}
+
+fn buy_miner(mut wallet: &mut Wallet) -> Result<(PurchaseType, Purchase), Error> {
     if wallet.max_miners >= ABS_MAX_MINERS {
         return Err(Error::new(
             ErrorKind::InvalidData,
@@ -212,14 +279,40 @@ fn buy_miner(mut wallet: &mut Wallet) -> Result<u64, Error> {
     };
     wallet.max_miners += 1;
 
-    Ok(cost)
+    Ok((
+        PurchaseType::Miner,
+        Purchase {
+            bought: 1,
+            cost: cost as u128,
+        },
+    ))
+}
+
+fn buy_max_miner(wallet: &mut Wallet) -> Option<(PurchaseType, Purchase)> {
+    let mut totals = Purchase::new();
+
+    loop {
+        let (_, p) = match buy_miner(wallet) {
+            Ok(m) => m,
+            Err(_) => return Some((PurchaseType::Miner, totals)),
+        };
+
+        totals += p;
+    }
 }
 
 pub fn time_cost() -> u64 {
     1000
 }
 
-fn buy_time(connection: &mut Connection, wallet: &mut Wallet) -> Result<u64, Error> {
+pub fn time_max_cost(chrono: u64) -> u64 {
+    (chrono / 1000) * 1000
+}
+
+fn buy_time(
+    connection: &mut Connection,
+    wallet: &mut Wallet,
+) -> Result<(PurchaseType, Purchase), Error> {
     if wallet.sub_chronocoins(time_cost()).is_err() {
         return Err(Error::new(
             ErrorKind::InvalidData,
@@ -236,5 +329,27 @@ fn buy_time(connection: &mut Connection, wallet: &mut Wallet) -> Result<u64, Err
         }
     }
 
-    Ok(time_cost())
+    Ok((
+        PurchaseType::Chrono,
+        Purchase {
+            bought: 1,
+            cost: time_cost() as u128,
+        },
+    ))
+}
+
+fn buy_max_time(
+    connection: &mut Connection,
+    wallet: &mut Wallet,
+) -> Option<(PurchaseType, Purchase)> {
+    let mut totals = Purchase::new();
+
+    loop {
+        let (_, p) = match buy_time(connection, wallet) {
+            Ok(t) => t,
+            Err(_) => return Some((PurchaseType::Chrono, totals)),
+        };
+
+        totals += p;
+    }
 }

src/commands.rs

@@ -150,6 +150,15 @@ fn main() -> Result<(), Error> {
                 }
             };
 
+            // Set write timeout
+            match s.set_write_timeout(Some(Duration::from_millis(500))) {
+                Ok(_) => (),
+                Err(e) => {
+                    println!("Unable to set write timeout: {e}");
+                    continue;
+                }
+            };
+
             let updates = vec![format!(
                 "\nLogged in as Wallet: {}0x{:016x}{} Miner: {}0x{:08x}{}\n",
                 PURPLE, miner.wallet_id, RST, BLUE, miner.miner_id, RST
@@ -386,8 +395,11 @@ fn print_wallets(
                     if c.miner.cps > 1024 {
                         c.purchases.push(
                             format!(
-                                "'b'<enter>\tPurchase 128 seconds of Miner Boost for {} idlecoin\n",
-                                commands::boost_cost(c.miner.cps)
+                                "{}b{}: Purchase 128 seconds of Miner Boost for {} idlecoin / {}B{}: Purchase Max for {} idlecoin\n",
+                                RED, RST,
+                                commands::boost_cost(c.miner.cps),
+                                RED, RST,
+                                commands::boost_max_cost(c.miner.cps, c.miner.boost),
                             )
                             .to_string(),
                         );
@@ -396,13 +408,13 @@ fn print_wallets(
                     if g.max_miners < ABS_MAX_MINERS && (g.idlecoin > miner_cost || g.supercoin > 1)
                     {
                         c.purchases.push(format!(
-                            "'m'<enter>\tPurchase 1 Miner License for {} idlecoin\n",
-                            miner_cost
+                            "{}m{}: Purchase 1 Miner License for {} idlecoin\n",
+                            RED, RST, miner_cost
                         ));
                     }
                 }
                 if g.chronocoin > commands::time_cost() {
-                    c.purchases.push(format!("'c'<enter>\tPurchase 60m of time travel for this miner for {} chronocoins\n", commands::time_cost()));
+                    c.purchases.push(format!("{}c{}: Purchase 1 hour of time travel for this miner for {} chronocoin / {}C{}: Purchase Max for {} chronocoin\n", RED, RST,commands::time_cost(), RED, RST,commands::time_max_cost(g.chronocoin)));
                 }
 
                 // Build miner display