Dynamic Weather & Seasons 1.0.2

/*
 * DynamicWeatherAndSeasons v1.0.1
 * MIT License
 * Copyright (c) 2024 PreyToLive
 */

/* eslint-disable @typescript-eslint/no-var-requires */
/* eslint-disable @typescript-eslint/brace-style */

import { DependencyContainer } from "tsyringe";
import { WeatherCallbacks } from "@spt/callbacks/WeatherCallbacks";
import { PreSptModLoader } from "@spt/loaders/PreSptModLoader";
import { ConfigTypes } from "@spt/models/enums/ConfigTypes";
import { IPostSptLoadMod } from "@spt/models/external/IPostSptLoadMod";
import { IEmptyRequestData } from "@spt/models/eft/common/IEmptyRequestData";
import { IWeatherConfig } from "@spt/models/spt/config/IWeatherConfig";
import { ILogger } from "@spt/models/spt/utils/ILogger";
import { ConfigServer } from "@spt/servers/ConfigServer";
import { StaticRouterModService } from "@spt/services/mod/staticRouter/StaticRouterModService";
import { LoggerTypes } from "../enums/DWSEnumLogger";
import * as path from "path";
import * as fs from "fs";
import pkg from "../package.json";

class DWSMain implements IPostSptLoadMod {
    private logger: ILogger;
    private weatherCallbacks: WeatherCallbacks;

    public preSptLoad(container: DependencyContainer): void {
        this.logger = container.resolve<ILogger>("WinstonLogger");
        this.weatherCallbacks = container.resolve<WeatherCallbacks>("WeatherCallbacks");

        const preSptModLoader = container.resolve<PreSptModLoader>("PreSptModLoader");
        const staticRouterModService: StaticRouterModService = container.resolve<StaticRouterModService>("StaticRouterModService");

        const modName = `${pkg.author}-${pkg.name}-v${pkg.version}`;
        const modPath = preSptModLoader.getModPath(path.basename(path.dirname(__dirname.split('/').pop())));

        const dbProfile = require("../db/profile.json");

        let profileDay = dbProfile.date.day;
        let profileMonth = dbProfile.date.month;
        let profileYear = dbProfile.date.year;
        let profileSeason = dbProfile.season;

        staticRouterModService.registerStaticRouter(
            `[${pkg.name}] /client/items`,
            [
                {
                    url: "/client/items",
                    action: (url: string, info: any, sessionID: string, output: string): any => {
                        try {
                            const sptConfigsWeather: IWeatherConfig = container.resolve<ConfigServer>("ConfigServer").getConfig<IWeatherConfig>(ConfigTypes.WEATHER);

                            const dbConfig = require("../config/config.json");
                            const dbWeather = require("../db/weather.json");

                            if (dbConfig.modEnabled) {

                                // START UPDATE PROFILE

                                const monthDurationInRaids = dbConfig.monthDurationInRaids;
                                const monthIndices = {
                                    january: 1,
                                    february: 2,
                                    march: 3,
                                    april: 4,
                                    may: 5,
                                    june: 6,
                                    july: 7,
                                    august: 8,
                                    september: 9,
                                    october: 10,
                                    november: 11,
                                    december: 12
                                }

                                profileDay++;
                                if (profileDay > monthDurationInRaids) {
                                    const monthIndex = monthIndices[profileMonth] || 1;
                                    const nextMonthIndex = monthIndex === 12 ? 1 : monthIndex + 1;

                                    profileDay = 1;
                                    profileMonth = Object.keys(monthIndices).find(key => monthIndices[key] === nextMonthIndex) || "january";

                                    if (nextMonthIndex === 1) {
                                        profileYear++;
                                    }
                                }
                                if (dbConfig.randomMonthEachRaid) {
                                    const randomMonthIndex = Math.floor(Math.random() * 12) + 1
                                    profileMonth = Object.keys(monthIndices).find(key => monthIndices[key] === randomMonthIndex);
                                }
                                profileSeason = dbConfig.months[profileMonth];

                                // START UPDATE WEATHER AND SEASONS

                                const weatherSelections: Record<string, number> = {};
                                for (const [key, value] of Object.entries(dbConfig.seasons[profileSeason].weather)) {
                                    if (Array.isArray(value) && value.length > 0) {
                                        const selectedValue = value[Math.floor(Math.random() * value.length)];
                                        if (typeof selectedValue === "number") {
                                            weatherSelections[key] = selectedValue;
                                        }
                                    }
                                }
                                const { clouds, rain, wind, fog, temp, pressure } = weatherSelections;

                                // CLOUDS
                                const cloudsProfileDesc: string[] = [
                                    "clear sky",
                                    "partly cloudy",
                                    "mostly cloudy",
                                    "overcast with scattered clouds",
                                    "completely overcast with thick clouds"
                                ];
                                const cloudsProfile = cloudsProfileDesc[clouds];
                                sptConfigsWeather.weather.clouds = dbWeather.clouds[clouds];

                                // RAIN
                                const rainProfileDesc: string[] = [
                                    "no rain",
                                    "light rain",
                                    "moderate rain",
                                    "heavy rain",
                                    "intense rain"
                                ];
                                let rainProfile: string;
                                if (clouds === 0) {
                                    rainProfile = rainProfileDesc[0];
                                    sptConfigsWeather.weather.rain = dbWeather.rain[0];
                                    sptConfigsWeather.weather.rainIntensity = dbWeather.rainIntensity[0];
                                } else {
                                    rainProfile = rainProfileDesc[rain];
                                    sptConfigsWeather.weather.rain = dbWeather.rain[rain];
                                    sptConfigsWeather.weather.rainIntensity = dbWeather.rainIntensity[rain];
                                }

                                // WIND
                                const windProfileDesc: string[] = [
                                    "calm",
                                    "gentle breeze",
                                    "moderate breeze",
                                    "strong wind",
                                    "stormy wind"
                                ];
                                const windProfile = windProfileDesc[wind];
                                sptConfigsWeather.weather.windSpeed = dbWeather.windSpeed[wind];
                                sptConfigsWeather.weather.windGustiness = dbWeather.windGustiness[wind];

                                const seasonIndices: Record<string, number> = {
                                    "spring": 1,
                                    "summer": 2,
                                    "autumn": 3,
                                    "winter": 4
                                };
                                const seasonIndex = seasonIndices[profileSeason] || 0;
                                sptConfigsWeather.weather.windDirection = dbWeather.windDirection[seasonIndex];

                                // FOG
                                const fogProfileDesc: string[] = [
                                    "no fog",
                                    "light fog",
                                    "moderate fog",
                                    "dense fog",
                                    "thick fog"
                                ];
                                const fogProfile = fogProfileDesc[fog];
                                sptConfigsWeather.weather.fog = dbWeather.fog[fog];

                                // TEMP
                                const tempProfileDesc: string[] = [
                                    "very cold",
                                    "cold",
                                    "mild",
                                    "warm",
                                    "hot"
                                ];
                                const tempProfile = tempProfileDesc[temp];
                                sptConfigsWeather.weather.temp = dbWeather.temp[temp];

                                // PRESSURE
                                const pressureProfileDesc: string[] = [
                                    "very low pressure",
                                    "low pressure",
                                    "normal pressure",
                                    "high pressure",
                                    "very high pressure"
                                ];
                                const pressureProfile = pressureProfileDesc[pressure];
                                sptConfigsWeather.weather.pressure = dbWeather.pressure[pressure];

                                // SEASON
                                let seasonOverrideValue: number;
                                if (profileSeason === "spring") {
                                    seasonOverrideValue = 3;
                                } else if (profileSeason === "summer") {
                                    if (clouds >= 3 && rain >= 3) {
                                        seasonOverrideValue = 4;
                                    } else {
                                        seasonOverrideValue = 0;
                                    }
                                } else if (profileSeason === "autumn") {
                                    seasonOverrideValue = 1;
                                } else if (profileSeason === "winter") {
                                    seasonOverrideValue = 2;
                                } else {
                                    seasonOverrideValue = Math.floor(Math.random() * 4);
                                }
                                sptConfigsWeather.overrideSeason = seasonOverrideValue;

                                // END UPDATE WEATHER AND SEASONS

                                const newProfileData = {
                                    mod: modName,
                                    date: {
                                        day: profileDay,
                                        month: profileMonth,
                                        year: profileYear
                                    },
                                    season: profileSeason,
                                    weather: {
                                        clouds: cloudsProfile,
                                        rain: rainProfile,
                                        wind: windProfile,
                                        fog: fogProfile,
                                        temp: tempProfile,
                                        pressure: pressureProfile
                                    }
                                }

                                const profilePath = path.join(modPath, "PreyToLive-DynamicWeatherAndSeasons/db/profile.json");
                                fs.writeFileSync(profilePath, JSON.stringify(newProfileData, null, 4));

                                // END UPDATE PROFILE

                                if (dbConfig.consoleLogs) {
                                    this.logger.log(`Mod: ${pkg.name}: console logs`, LoggerTypes.INFO);
                                    this.logger.log(`season: ${profileSeason}`, LoggerTypes.INFO);
                                    this.logger.log(`weather: clouds: ${clouds}: ${cloudsProfile}`, LoggerTypes.INFO);
                                    this.logger.log(`weather: rain: ${rain}: ${rainProfile}`, LoggerTypes.INFO);
                                    this.logger.log(`weather: wind: ${wind}: ${windProfile}`, LoggerTypes.INFO);
                                    this.logger.log(`weather: fog: ${fog}: ${fogProfile}`, LoggerTypes.INFO);
                                    this.logger.log(`weather: temp: ${temp}: ${tempProfile}`, LoggerTypes.INFO);
                                    this.logger.log(`weather: pressure: ${pressure}: ${pressureProfile}`, LoggerTypes.INFO);
                                }
                            }
                        } catch (err) {
                            this.logger.error(`Error in [${pkg.name}] /client/items: ${err.message}`);
                        }
                        return output;
                    }
                }
            ],

{
"acceleration": 7,
"weather": {
"clouds": {
"values": [-1.5, -1, 0, 0.5, 1, 1.5],
"weights": [60, 50, 15, 5, 4, 3]
},
"windSpeed": {
"values": [0, 1, 2, 3],
"weights": [4, 3, 2, 1]
},
"windDirection": {
"values": [1, 2, 3, 4, 5, 6, 7, 8],
"weights": [1, 1, 1, 1, 1, 1, 1, 1]
},
"windGustiness": {
"min": 0,
"max": 1
},
"rain": {
"values": [1, 2, 3],
"weights": [25, 1, 1]
},
"rainIntensity": {
"min": 0,
"max": 1
},
"fog": {
"values": [0.002, 0.004, 0.008, 0.012, 0.087],
"weights": [20, 8, 5, 5, 1]
},
"temp": {
"min": 0,
"max": 24
},
"pressure": {
"min": 760,
"max": 764
}
},
"seasonDates": [
{ "seasonType": 0, "name": "SUMMER", "startDay": "1", "startMonth": "1", "endDay": "31", "endMonth": "12" },
{ "seasonType": 1, "name": "AUTUMN", "startDay": "1", "startMonth": "1", "endDay": "31", "endMonth": "12" },
{ "seasonType": 2, "name": "WINTER", "startDay": "1", "startMonth": "1", "endDay": "31", "endMonth": "12" },
{ "seasonType": 3, "name": "SPRING", "startDay": "1", "startMonth": "1", "endDay": "31", "endMonth": "12" },
{ "seasonType": 4, "name": "STORM", "startDay": "1", "startMonth": "1", "endDay": "31", "endMonth": "12" }
],
"overrideSeason": null
}