health, food consumption and pop growth linked, 1st draft

Author: JoeHowarth

.idea/workspace.xml

@@ -0,0 +1,6 @@
+{
+ "cells": [],
+ "metadata": {},
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

notebooks/.ipynb_checkpoints/health-checkpoint.ipynb

@@ -55,7 +55,7 @@ pub fn base_yield(seed_ratio: u8, area: f32, fertility: f32) -> f32 {
     bpkm * area * FALLOW_MULT
 }
 
-// Normal grain consumption for cohort
+/// Normal yearly grain consumption for cohort
 pub fn grain_for_cohort(c: &Cohort) -> f32 {
     let &Cohort { pop, mean_age, male, .. } = c;
     let bm = if mean_age < 14. {
@@ -73,6 +73,7 @@ pub fn grain_for_cohort(c: &Cohort) -> f32 {
     (bm * pop as f64 * male + bf as f64 * pop as f64 * (1. - male)) as f32
 }
 
+/// normal yearly grain cosump for pop
 pub fn grain_for_pop(p: &RegionPop) -> f32 {
     p.cohorts.iter().fold(0., |grain, c| grain_for_cohort(c) + grain)
 }

notebooks/health.ipynb

@@ -40,10 +40,10 @@ pub struct FoodConsumption {
 #[derive(Component, Clone, Debug, Serialize, Deserialize, PartialOrd, PartialEq, TypescriptDefinition)]
 pub struct PopEst(pub usize);
 
-const NUM_COHORTS: usize = 17;
+pub const NUM_COHORTS: usize = 17;
 
 impl RegionPop {
-    pub fn new(dist: &[f32; NUM_COHORTS], pop: usize) -> RegionPop {
+    pub fn new(dist: &[f32], pop: usize) -> RegionPop {
         let cohorts = (0..NUM_COHORTS).map(|i| {
             Cohort::new(i * 5, dist[i as usize], pop)
         }).collect();
@@ -53,7 +53,7 @@ impl RegionPop {
         }
     }
 
-    pub fn update(&mut self, brs: &[f32; NUM_COHORTS], drs: &[f32; NUM_COHORTS], dt: u16) {
+    pub fn update(&mut self, brs: &[f32], drs: &[f32], dt: u16) {
         let mut newborns = 0;
         for c in &mut self.cohorts {
             let br = lerp_pop_arr(c.mean_age, brs);
@@ -141,7 +141,7 @@ impl Cohort {
     }
 }
 
-pub fn lerp_pop_arr(x: f64, arr: &[f32; NUM_COHORTS]) -> f64 {
+pub fn lerp_pop_arr(x: f64, arr: &[f32]) -> f64 {
     let l_i = (x / 5.).floor() as usize;
     let h_i = (x / 5.).ceil() as usize;
     let l: f64 = (arr[l_i].clone()).into();

src/agriculture/systems.rs

@@ -4,7 +4,15 @@ use specs_derive;
 use crate::misc::time::Date;
 use chrono::Datelike;
 use crate::prelude::*;
+use crate::pop::NUM_COHORTS;
 
+const DEATH_RATES: [f32; 17] = [
+    0.2, 0.045, 0.035, 0.02, 0.007, 0.005, 0.005, 0.005,
+    0.01, 0.015, 0.02, 0.03, 0.04, 0.06, 0.1, 0.3, 0.8
+];
+const BIRTH_RATES: [f32; 17] = [0., 0., 0., 0.01, 0.02, 0.55, 0.45, 0.25, 0.1, 0., 0., 0., 0., 0., 0., 0., 0.];
+const HARVEST_MONTH: u32 = 9;
+const HEALTH_CHANGE_RATE: f32 = 0.10;
 
 pub struct PopUpdate {
     pub old_date: Date,
@@ -13,14 +21,8 @@ pub struct PopUpdate {
 // Changes Cohort health in response to food scarcity, disease, sanitation etc.
 pub struct HealthUpdate;
 
-// The
-pub struct FoodConsumptionUpdate;
-
-const DEATH_RATES: [f32; 17] = [
-    0.2, 0.045, 0.035, 0.02, 0.007, 0.005, 0.005, 0.005,
-    0.01, 0.015, 0.02, 0.03, 0.04, 0.06, 0.1, 0.3, 0.8
-];
-const BIRTH_RATES: [f32; 17] = [0., 0., 0., 0.01, 0.02, 0.55, 0.45, 0.25, 0.1, 0., 0., 0., 0., 0., 0., 0., 0.];
+// Recalculate Monthly Food Consumption
+pub struct FoodConsumptionSystem;
 
 impl<'a> System<'a> for PopUpdate {
     type SystemData = (ReadStorage<'a, Health>,
@@ -34,61 +36,75 @@ impl<'a> System<'a> for PopUpdate {
             let dt = (*date - self.old_date).num_days();
             self.old_date = date.clone();
 
-//            if dt < 30 { return; }
-
 
-            let mut b = true;
             for (p, h) in (&mut pop, &health).join() {
-                p.update(&BIRTH_RATES, &DEATH_RATES, dt as u16);
-
-                if b {
-                    //dbg!(&p);
-                    b = false
-                }
+                let brs: ArrayVec<[f32; NUM_COHORTS]> = BIRTH_RATES.iter().map(|&br| br * h.health).collect();
+                let drs: ArrayVec<[f32; NUM_COHORTS]> = DEATH_RATES.iter().map(|&dr| dr * h.health).collect();
+                p.update(brs.as_slice(), &drs, dt as u16);
             }
         }
     }
 }
 
+
+
+
 impl<'a> System<'a> for HealthUpdate {
     type SystemData = (WriteStorage<'a, Health>,
-                       WriteStorage<'a, FoodConsumption>,
+                       ReadStorage<'a, FoodConsumption>,
                        ReadStorage<'a, FoodStock>);
 
-    fn run(&mut self, (health, consump, food): Self::SystemData) {}
+    fn run(&mut self, (mut health, consump, food): Self::SystemData) {
+        for (health, consump, food) in (&mut health, &consump, &food).join() {
+            let r = consump.ratio_of_norm;
+
+            // later add more interesting interactions with other systems
+            let target_health = r;
+
+
+            // half-life for health change is .7/rate, so .10 rate
+            //    ==> will get to half the difference in 7 months (periods)
+            health.health += HEALTH_CHANGE_RATE * (target_health - health.health);
+        }
+    }
 }
 
-impl<'a> System<'a> for FoodConsumptionUpdate {
+impl<'a> System<'a> for FoodConsumptionSystem {
     type SystemData = (WriteStorage<'a, FoodStock>,
                        WriteStorage<'a, FoodConsumption>,
                        ReadStorage<'a, RegionPop>,
-                       ReadStorage<'a, Health>,
                        ReadExpect<'a, Date>);
 
-    fn run(&mut self, (mut stock, mut consump, pop, health, date): Self::SystemData) {
+    fn run(&mut self, (mut stock, mut consump, pop, date): Self::SystemData) {
         if date.day() != 3 {
             return;
         }
 
-        let months_2_harvest = ((9 - date.month()) % 12) as f32;
+        let months_2_harvest = ((HARVEST_MONTH - date.month()) % 12) as f32;
 
-        for (stock, mut consump, pop, health) in (&mut stock, &mut consump, &pop, &health).join() {
+        for (mut stock, mut consump, pop) in (&mut stock, &mut consump, &pop).join() {
             let base_grain = grain_for_pop(pop);
             let abundance = stock.bushels / (base_grain * months_2_harvest / 12.);
-            let r = if abundance > 1.3 {
+            let r = if abundance > 1.4 {
                 1.2
             } else if abundance > 0.8 {
                 abundance.sqrt()
             } else if abundance > 0.6 {
                 abundance
             } else {
-                0.65
+                0.6
             };
 
             consump.consump = base_grain * r / 12.;
             consump.ratio_of_norm = r;
+
+            stock.bushels = (stock.bushels - consump.consump).max(0.);
         }
     }
 }
 
+pub fn logistic(r: f32, x: f32, k: f32) -> f32 {
+    r * x * (k - x) / k
+}
+