basic forecasting

src/data.rs

@@ -3,7 +3,10 @@ use std::collections::HashMap;
 use chrono::Timelike;
 use serde::{Deserialize, Serialize};
 
-use crate::clock;
+use crate::{
+    clock,
+    forecast::{Forecast, ForecastSet, Rate},
+};
 
 const DATA: &'static str = include_str!("../data.json");
 
@@ -11,12 +14,22 @@ const DATA: &'static str = include_str!("../data.json");
 pub struct Data {
     pub db_data: SubData,
     pub fish_entries: Vec<FishMeta>,
+    #[serde(skip)]
+    pub forecasts: ForecastSet,
 }
 
 #[derive(Serialize, Deserialize, Debug)]
 pub struct SubData {
     #[serde(alias = "FISH")]
     pub fish: HashMap<u32, FishEntry>,
+    #[serde(alias = "ZONES")]
+    pub zones: HashMap<u32, Zone>,
+    #[serde(alias = "WEATHER_RATES")]
+    pub weather_rates: HashMap<u32, WeatherRate>,
+    #[serde(alias = "FISHING_SPOTS")]
+    pub fishing_spots: HashMap<u32, FishingSpot>,
+    #[serde(alias = "WEATHER_TYPES")]
+    pub weather_types: HashMap<u32, WeatherType>,
 }
 
 #[derive(Serialize, Deserialize, Debug)]
@@ -37,6 +50,31 @@ pub struct FishEntry {
     pub weather_set: Vec<u32>,
 }
 
+#[derive(Serialize, Deserialize, Debug)]
+pub struct Zone {
+    pub name_en: String,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct FishingSpot {
+    #[serde(alias = "_id")]
+    pub id: u32,
+    pub name_en: String,
+    #[serde(alias = "territory_id")] // not sure why it's named this, but thanks serde!
+    pub forecast_id: u32,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct WeatherRate {
+    pub zone_id: u32,
+    pub weather_rates: Vec<Vec<u32>>,
+}
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct WeatherType {
+    pub name_en: String,
+}
+
 #[derive(Serialize, Deserialize, Debug)]
 pub struct Location {
     pub id: u32,
@@ -71,13 +109,47 @@ impl<'a> CombinedFish<'a> {
             return start_hour < cur_hour && cur_hour < end_hour;
         }
     }
+
+    pub fn get_forecast<'b>(&self, data: &'b Data) -> Option<&'b Forecast> {
+        if self.entry.location.is_none() {
+            return None;
+        }
+        // Find the associated fishing spot.
+        let spot = data
+            .db_data
+            .fishing_spots
+            .get(&self.entry.location.unwrap())
+            .unwrap();
+        data.forecasts.get(&spot.forecast_id)
+    }
 }
 
 impl Data {
     pub fn new() -> Self {
         let json = &mut serde_json::Deserializer::from_str(DATA);
-        let json = serde_path_to_error::deserialize(json).unwrap();
+        let mut data: Self = serde_path_to_error::deserialize(json).unwrap();
-        json
+        data.forecasts = data
+            .db_data
+            .weather_rates
+            .iter()
+            .map(|(id, wr)| {
+                (
+                    id.clone(),
+                    Forecast {
+                        zone_id: wr.zone_id,
+                        rates: wr
+                            .weather_rates
+                            .iter()
+                            .map(|rate| Rate {
+                                weather_id: rate[0],
+                                rate: rate[1],
+                            })
+                            .collect(),
+                    },
+                )
+            })
+            .collect();
+        data
     }
 
     pub fn fish_with_meta(&self) -> HashMap<u32, CombinedFish> {
@@ -91,3 +163,11 @@ impl Data {
             .collect()
     }
 }
+
+pub fn get_weather_name(data: &Data, id: u32) -> &str {
+    &data.db_data.weather_types.get(&id).unwrap().name_en
+}
+
+pub fn get_zone_name(data: &Data, id: u32) -> &str {
+    &data.db_data.zones.get(&id).unwrap().name_en
+}

src/forecast.rs

@@ -0,0 +1,64 @@
+use std::collections::HashMap;
+
+use chrono::{DateTime, NaiveTime, Timelike, Utc};
+
+/// A forecast is used to divine specific weather patterns for a zone.
+#[derive(Debug)]
+pub struct Forecast {
+    pub zone_id: u32,
+    pub rates: Vec<Rate>,
+}
+
+/// A weather rate consists of the Weather ID and the likelihood in which it occurs (also called "target").
+/// The weather algorithm that the game uses generates a random integer between 0 and 100, and whichever rate
+/// first satisfies the "is larger than target" condition gets selected.
+/// This means that rates are:
+/// 1. Sorted ascending by rate
+/// 2. The larger the rate, the less likely the weather is to occur, statistically
+#[derive(Debug)]
+pub struct Rate {
+    pub weather_id: u32,
+    pub rate: u32,
+}
+
+/// A hash map of zones, indexed by "rate ID", which is unique in our source data.
+pub type ForecastSet = HashMap<u32, Forecast>;
+
+impl Forecast {
+    pub fn weather_for_target(&self, target: u32) -> &Rate {
+        // TODO: Don't unwrap here!
+        self.rates.iter().find(|r| target < r.rate).unwrap()
+    }
+
+    pub fn weather_now(&self) -> &Rate {
+        let utc = Utc::now();
+        let target = calculate_target(utc);
+        self.weather_for_target(target)
+    }
+}
+
+/// Rounds to the last weather "start". These happen three times a day, at 0:00,
+/// at 8:00, and at 16:00.
+pub fn round_to_last_weather_time(date: &DateTime<Utc>) -> DateTime<Utc> {
+    let cur_hour = date.hour();
+    // This essentially performs division without rest.
+    let last_hour = (cur_hour / 8) * 8;
+    date.date_naive()
+        .and_hms_opt(last_hour, date.minute(), date.second())
+        .unwrap()
+        .and_utc()
+}
+
+/// Calculates the magic target number for a specific date.
+/// It's important to note that this expects a human time, not an Eorzean time.
+pub fn calculate_target(m: DateTime<Utc>) -> u32 {
+    let unix_time = m.timestamp().abs();
+    let ez_hour = unix_time / 175;
+    let inc = (ez_hour + 8 - (ez_hour % 8)) % 24;
+    let total_days = unix_time / 4200;
+    let calc_base: i32 = ((total_days * 100) + inc) as i32; // Needs to be i32 to assure correct shifting overflow!
+    let step1 = ((calc_base << 11) ^ calc_base) as u32; // Cast to u32 here to literally interpret the two's complement, I suppose
+    let step2 = (step1 >> 8) ^ step1;
+
+    step2 % 100
+}

src/main.rs

@@ -6,6 +6,7 @@ use maud::{html, Markup};
 
 pub mod clock;
 pub mod data;
+pub mod forecast;
 
 pub struct AppState {
     pub data: Data,
@@ -44,12 +45,16 @@ async fn main_handler(state: State<Arc<AppState>>) -> Result<Markup, AppError> {
                     "Up! "
                 }
                 (fish.meta.name_en)
-                br;
+                details {
-                @if fish.entry.start_hour.is_some() && fish.entry.end_hour.is_some() {
+                    @if fish.entry.start_hour.is_some() && fish.entry.end_hour.is_some() {
-                    "From " (fish.entry.start_hour.unwrap()) "h to " (fish.entry.end_hour.unwrap()) "h"
+                        "From " (fish.entry.start_hour.unwrap()) "h to " (fish.entry.end_hour.unwrap()) "h"
-                }
+                    }
-                @if fish.entry.weather_set.len() > 0 {
+                    @if fish.entry.weather_set.len() > 0 {
-                    " Weather(s) " (fish.entry.weather_set.iter().map(|i| i.to_string()).collect::<Vec<_>>().join(", "))
+                        " Weather(s) " (fish.entry.weather_set.iter().map(|i| i.to_string()).collect::<Vec<_>>().join(", "))
+                    }
+                    @if let Some(forecast) = fish.get_forecast(&state.data) {
+                        "Current weather in " (data::get_zone_name(&state.data, forecast.zone_id)) ": " (data::get_weather_name(&state.data, forecast.weather_now().weather_id))
+                    }
                 }
             }
         }