nomicon/games/rstnode/src/stats.rs

//! 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,
        }
    }
}