diff options
Diffstat (limited to 'games/rstnode/src/stats.rs')
-rw-r--r-- | games/rstnode/src/stats.rs | 183 |
1 files changed, 183 insertions, 0 deletions
diff --git a/games/rstnode/src/stats.rs b/games/rstnode/src/stats.rs new file mode 100644 index 000000000000..1c651a98a0a8 --- /dev/null +++ b/games/rstnode/src/stats.rs @@ -0,0 +1,183 @@ +//! This file contains balancing data +//! +//! Each type of node and packet is being balanced for different +//! factors. The stats are just returned by these functions. +//! Whenever there is some effect that can happen in the game, it's +//! value (strength) will be derived from here. + +pub type Money = usize; + +/// The cost of doing business +pub mod costs { + use super::Money; + use crate::data::{Level, PacketType, Upgrade}; + + /// Takes the current node and desired upgrade level + pub fn upgrade(curr: &Upgrade, want: &Upgrade) -> Money { + use self::{Level::*, Upgrade::*}; + match (curr, want) { + // Base upgrades + (Base, Guard(One)) => 30, + (Base, Compute(One)) => 25, + (Base, Relay(One)) => 20, + + // Guards + (Guard(One), Guard(Two)) => 50, + (Guard(Two), Guard(Three)) => 75, + + // Compute is expensive + (Compute(One), Compute(Two)) => 50, + (Compute(Two), Compute(Three)) => 95, + + // Relays + (Relay(One), Relay(Two)) => 35, + (Relay(Two), Relay(Three)) => 55, + + // Can't touch this + (_, _) => unreachable!(), + } + } + + /// Sending certain packets costs money, let's find out how much + pub fn packets(node: &Upgrade, packet: &PacketType) -> Money { + use { + Level::*, + PacketType::*, + Upgrade::{Base, Compute as Cc, Guard, Relay}, + }; + match (node, packet) { + // Sending pings is free forever + (_, Ping) => 0, + // Capture packets always cost the same + (_, Capture) => 15, + + // The cost of compute packets increases with levels + // because their efficiency increases more dramatically + (Cc(One), Compute { .. }) => 7, + (Cc(Two), Compute { .. }) => 14, + (Cc(Three), Compute { .. }) => 21, + + // Payloads can only be sent from guards + (Guard(_), Payload { .. }) => 12, + + // Resets are relatively cheap + (Guard(One), Reset) => 16, + (Guard(Two), Reset) => 32, + (Guard(Three), Reset) => 48, + + (Guard(One), CNS) => 22, + (Guard(Two), CNS) => 40, + (Guard(Three), CNS) => 82, + + (Guard(Two), Nitm) => 64, + (Guard(Three), Nitm) => 148, + + (Guard(Two), Virus) => 40, + (Guard(Three), Virus) => 60, + + // Only level 3 guards can send takeovers + (Guard(Three), TakeOver) => 256, + + // Can't touch this + (_, _) => unreachable!(), + } + } +} + +/// This is what capitalists are all the rage about +pub mod gains { + use super::Money; + use crate::data::{Level, PacketType, Upgrade}; + use std::sync::atomic::Ordering; + + /// This will tell you if you'll receive any money this week + pub fn parse_packet(node: &Upgrade, packet: &PacketType) -> Money { + use { + Level::*, + PacketType::*, + Upgrade::{Base, Compute as Cc, Guard, Relay}, + }; + + /// A utility function which increments the packet progress + /// + /// Depending on the node that is processing the incoming + /// packet, progress is either stepped by 1, 1.5, or 2 times + /// the advertised step rate, which is set by the spawning + /// node of the compute job. This means that stronger compute + /// nodes have a positive impact even in mostly low-level + /// systems. + /// + /// This function returns if it reached or overflowed the max + fn incr_compute(l: &Level, packet: &PacketType) -> bool { + match (l, packet) { + (lvl, Compute { max, curr, step }) => { + if curr.load(Ordering::Relaxed) < *max { + curr.fetch_add( + match lvl { + One => *step, + Two => (*step as f32 * 1.5) as u16, + Three => *step * 2, + }, + Ordering::Relaxed, + ); + } + + // Did we reach the target? + curr.load(Ordering::Relaxed) >= *max + } + (_, _) => unreachable!(), + } + } + + match (node, packet) { + // A basic income for all node and packets + (Base, Ping) => 4, + (Guard(One), Ping) | (Cc(One), Ping) | (Relay(One), Ping) => 6, + (Guard(Two), Ping) | (Cc(Two), Ping) | (Relay(Two), Ping) => 11, + (Guard(Three), Ping) | (Cc(Three), Ping) | (Relay(Three), Ping) => 17, + + // A compute node will always increment the packet + // reference. If it made it to "max", it will then also + // return an amount of money that can be gained + (Cc(ref lvl), Compute { ref max, .. }) if incr_compute(lvl, packet) => match lvl { + One => *max as usize, + Two => (max * 2) as usize, + Three => (max * 3) as usize, + }, + + // If in doubt, nada! + (_, _) => 0, + } + } +} + +pub mod strengths { + use crate::data::Level::{self, *}; + + /// Determine the maximum amount of resources for a compute packet + pub fn compute_max(lvl: Level) -> u16 { + match lvl { + One => 65, + Two => 120, + Three => 250, + } + } + + /// Determine the step size by which a computation advances + pub fn compute_step(lvl: Level) -> u16 { + match lvl { + One => 7, + Two => 20, + Three => 32, + } + } + + /// Determine the reward gained from processing a payload packet + pub fn payload_reward(lvl: Level) -> u16 { + match lvl { + One => 70, + Two => 150, + Three => 275, + } + } +} |