From 7ca9bb35a364ebfddf2ac9b19970b12793007c18 Mon Sep 17 00:00:00 2001 From: Tyler Trahan Date: Thu, 14 Dec 2023 18:09:23 -0500 Subject: [PATCH] Change: Compatibility layers for AI and GS map ScriptDate:: to ScriptDateEcomomy:: --- bin/ai/compat_0.7.nut | 27 +++++++++++----- bin/ai/compat_1.0.nut | 20 ++++++++++++ bin/ai/compat_1.1.nut | 20 ++++++++++++ bin/ai/compat_1.10.nut | 20 ++++++++++++ bin/ai/compat_1.11.nut | 20 ++++++++++++ bin/ai/compat_1.2.nut | 20 ++++++++++++ bin/ai/compat_1.3.nut | 20 ++++++++++++ bin/ai/compat_1.4.nut | 20 ++++++++++++ bin/ai/compat_1.5.nut | 20 ++++++++++++ bin/ai/compat_1.6.nut | 20 ++++++++++++ bin/ai/compat_1.7.nut | 20 ++++++++++++ bin/ai/compat_1.8.nut | 20 ++++++++++++ bin/ai/compat_1.9.nut | 20 ++++++++++++ bin/ai/compat_12.nut | 20 ++++++++++++ bin/ai/compat_13.nut | 20 ++++++++++++ bin/game/compat_1.10.nut | 52 +++++++++++++++++++++++++++++++ bin/game/compat_1.11.nut | 52 +++++++++++++++++++++++++++++++ bin/game/compat_1.2.nut | 52 +++++++++++++++++++++++++++++++ bin/game/compat_1.3.nut | 52 +++++++++++++++++++++++++++++++ bin/game/compat_1.4.nut | 52 +++++++++++++++++++++++++++++++ bin/game/compat_1.5.nut | 52 +++++++++++++++++++++++++++++++ bin/game/compat_1.6.nut | 52 +++++++++++++++++++++++++++++++ bin/game/compat_1.7.nut | 52 +++++++++++++++++++++++++++++++ bin/game/compat_1.8.nut | 52 +++++++++++++++++++++++++++++++ bin/game/compat_1.9.nut | 52 +++++++++++++++++++++++++++++++ bin/game/compat_12.nut | 52 +++++++++++++++++++++++++++++++ bin/game/compat_13.nut | 52 +++++++++++++++++++++++++++++++ src/script/api/ai_changelog.hpp | 4 +++ src/script/api/game_changelog.hpp | 4 +++ 29 files changed, 932 insertions(+), 7 deletions(-) diff --git a/bin/ai/compat_0.7.nut b/bin/ai/compat_0.7.nut index 341b543bd3..ff0be6bc62 100644 --- a/bin/ai/compat_0.7.nut +++ b/bin/ai/compat_0.7.nut @@ -186,13 +186,6 @@ AIEngine.GetMaxTractiveEffort <- function(engine_id) return AIEngine._GetMaxTractiveEffort(engine_id); } -AIEngine._GetDesignDate <- AIEngine.GetDesignDate; -AIEngine.GetDesignDate <- function(engine_id) -{ - if (!AIEngine.IsBuildable(engine_id)) return -1; - return AIEngine._GetDesignDate(engine_id); -} - AIEngine._GetVehicleType <- AIEngine.GetVehicleType; AIEngine.GetVehicleType <- function(engine_id) { @@ -392,3 +385,23 @@ AIRoad.HasRoadType <- function(tile, road_type) } return false; } + +/* 14 splits date into calendar and economy time. Economy time ticks at the usual rate, but calendar time can be sped up, slowed down, or frozen entirely. + * For maximum compatibility, all ScriptDate calls go to TimerGameEcomomy. */ +AIDate <- AIDateEconomy; + +AIBaseStation._GetConstructionDate <- AIBaseStation.GetConstructionDate; +AIBaseStation.GetConstructionDate <- function(station_id) +{ + if (!IsValidBaseStation(station_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::BaseStation::Get(station_id)->build_date.base(); +} + +AIEngine._GetDesignDate <- AIScriptEngine.GetDesignDate; +AIEngine.GetDesignDate <- function(engine_id) +{ + if (!IsValidEngine(engine_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::Engine::Get(engine_id)->intro_date.base(); +} diff --git a/bin/ai/compat_1.0.nut b/bin/ai/compat_1.0.nut index 6b76f11534..61e5932ca9 100644 --- a/bin/ai/compat_1.0.nut +++ b/bin/ai/compat_1.0.nut @@ -144,3 +144,23 @@ AIRoad.HasRoadType <- function(tile, road_type) } return false; } + +/* 14 splits date into calendar and economy time. Economy time ticks at the usual rate, but calendar time can be sped up, slowed down, or frozen entirely. + * For maximum compatibility, all ScriptDate calls go to TimerGameEcomomy. */ +AIDate <- AIDateEconomy; + +AIBaseStation._GetConstructionDate <- AIBaseStation.GetConstructionDate; +AIBaseStation.GetConstructionDate <- function(station_id) +{ + if (!IsValidBaseStation(station_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::BaseStation::Get(station_id)->build_date.base(); +} + +AIEngine._GetDesignDate <- AIScriptEngine.GetDesignDate; +AIEngine.GetDesignDate <- function(engine_id) +{ + if (!IsValidEngine(engine_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::Engine::Get(engine_id)->intro_date.base(); +} diff --git a/bin/ai/compat_1.1.nut b/bin/ai/compat_1.1.nut index 9c568a7006..c88f1f2bde 100644 --- a/bin/ai/compat_1.1.nut +++ b/bin/ai/compat_1.1.nut @@ -81,3 +81,23 @@ AIRoad.HasRoadType <- function(tile, road_type) } return false; } + +/* 14 splits date into calendar and economy time. Economy time ticks at the usual rate, but calendar time can be sped up, slowed down, or frozen entirely. + * For maximum compatibility, all ScriptDate calls go to TimerGameEcomomy. */ +AIDate <- AIDateEconomy; + +AIBaseStation._GetConstructionDate <- AIBaseStation.GetConstructionDate; +AIBaseStation.GetConstructionDate <- function(station_id) +{ + if (!IsValidBaseStation(station_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::BaseStation::Get(station_id)->build_date.base(); +} + +AIEngine._GetDesignDate <- AIScriptEngine.GetDesignDate; +AIEngine.GetDesignDate <- function(engine_id) +{ + if (!IsValidEngine(engine_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::Engine::Get(engine_id)->intro_date.base(); +} diff --git a/bin/ai/compat_1.10.nut b/bin/ai/compat_1.10.nut index 44bc2542ce..41af10a980 100644 --- a/bin/ai/compat_1.10.nut +++ b/bin/ai/compat_1.10.nut @@ -19,3 +19,23 @@ AIRoad.HasRoadType <- function(tile, road_type) } return false; } + +/* 14 splits date into calendar and economy time. Economy time ticks at the usual rate, but calendar time can be sped up, slowed down, or frozen entirely. + * For maximum compatibility, all ScriptDate calls go to TimerGameEcomomy. */ +AIDate <- AIDateEconomy; + +AIBaseStation._GetConstructionDate <- AIBaseStation.GetConstructionDate; +AIBaseStation.GetConstructionDate <- function(station_id) +{ + if (!IsValidBaseStation(station_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::BaseStation::Get(station_id)->build_date.base(); +} + +AIEngine._GetDesignDate <- AIScriptEngine.GetDesignDate; +AIEngine.GetDesignDate <- function(engine_id) +{ + if (!IsValidEngine(engine_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::Engine::Get(engine_id)->intro_date.base(); +} diff --git a/bin/ai/compat_1.11.nut b/bin/ai/compat_1.11.nut index 3d8370ffc6..1c85b4c6cf 100644 --- a/bin/ai/compat_1.11.nut +++ b/bin/ai/compat_1.11.nut @@ -19,3 +19,23 @@ AIRoad.HasRoadType <- function(tile, road_type) } return false; } + +/* 14 splits date into calendar and economy time. Economy time ticks at the usual rate, but calendar time can be sped up, slowed down, or frozen entirely. + * For maximum compatibility, all ScriptDate calls go to TimerGameEcomomy. */ +AIDate <- AIDateEconomy; + +AIBaseStation._GetConstructionDate <- AIBaseStation.GetConstructionDate; +AIBaseStation.GetConstructionDate <- function(station_id) +{ + if (!IsValidBaseStation(station_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::BaseStation::Get(station_id)->build_date.base(); +} + +AIEngine._GetDesignDate <- AIScriptEngine.GetDesignDate; +AIEngine.GetDesignDate <- function(engine_id) +{ + if (!IsValidEngine(engine_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::Engine::Get(engine_id)->intro_date.base(); +} diff --git a/bin/ai/compat_1.2.nut b/bin/ai/compat_1.2.nut index fc52b04935..b5733de0b7 100644 --- a/bin/ai/compat_1.2.nut +++ b/bin/ai/compat_1.2.nut @@ -33,3 +33,23 @@ AIRoad.HasRoadType <- function(tile, road_type) } return false; } + +/* 14 splits date into calendar and economy time. Economy time ticks at the usual rate, but calendar time can be sped up, slowed down, or frozen entirely. + * For maximum compatibility, all ScriptDate calls go to TimerGameEcomomy. */ +AIDate <- AIDateEconomy; + +AIBaseStation._GetConstructionDate <- AIBaseStation.GetConstructionDate; +AIBaseStation.GetConstructionDate <- function(station_id) +{ + if (!IsValidBaseStation(station_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::BaseStation::Get(station_id)->build_date.base(); +} + +AIEngine._GetDesignDate <- AIScriptEngine.GetDesignDate; +AIEngine.GetDesignDate <- function(engine_id) +{ + if (!IsValidEngine(engine_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::Engine::Get(engine_id)->intro_date.base(); +} diff --git a/bin/ai/compat_1.3.nut b/bin/ai/compat_1.3.nut index a06e98d2dd..3148d551d1 100644 --- a/bin/ai/compat_1.3.nut +++ b/bin/ai/compat_1.3.nut @@ -33,3 +33,23 @@ AIRoad.HasRoadType <- function(tile, road_type) } return false; } + +/* 14 splits date into calendar and economy time. Economy time ticks at the usual rate, but calendar time can be sped up, slowed down, or frozen entirely. + * For maximum compatibility, all ScriptDate calls go to TimerGameEcomomy. */ +AIDate <- AIDateEconomy; + +AIBaseStation._GetConstructionDate <- AIBaseStation.GetConstructionDate; +AIBaseStation.GetConstructionDate <- function(station_id) +{ + if (!IsValidBaseStation(station_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::BaseStation::Get(station_id)->build_date.base(); +} + +AIEngine._GetDesignDate <- AIScriptEngine.GetDesignDate; +AIEngine.GetDesignDate <- function(engine_id) +{ + if (!IsValidEngine(engine_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::Engine::Get(engine_id)->intro_date.base(); +} diff --git a/bin/ai/compat_1.4.nut b/bin/ai/compat_1.4.nut index 6de24bf80c..4fc17caff1 100644 --- a/bin/ai/compat_1.4.nut +++ b/bin/ai/compat_1.4.nut @@ -33,3 +33,23 @@ AIRoad.HasRoadType <- function(tile, road_type) } return false; } + +/* 14 splits date into calendar and economy time. Economy time ticks at the usual rate, but calendar time can be sped up, slowed down, or frozen entirely. + * For maximum compatibility, all ScriptDate calls go to TimerGameEcomomy. */ +AIDate <- AIDateEconomy; + +AIBaseStation._GetConstructionDate <- AIBaseStation.GetConstructionDate; +AIBaseStation.GetConstructionDate <- function(station_id) +{ + if (!IsValidBaseStation(station_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::BaseStation::Get(station_id)->build_date.base(); +} + +AIEngine._GetDesignDate <- AIScriptEngine.GetDesignDate; +AIEngine.GetDesignDate <- function(engine_id) +{ + if (!IsValidEngine(engine_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::Engine::Get(engine_id)->intro_date.base(); +} diff --git a/bin/ai/compat_1.5.nut b/bin/ai/compat_1.5.nut index 8ff5a39d15..bb86248fd1 100644 --- a/bin/ai/compat_1.5.nut +++ b/bin/ai/compat_1.5.nut @@ -33,3 +33,23 @@ AIRoad.HasRoadType <- function(tile, road_type) } return false; } + +/* 14 splits date into calendar and economy time. Economy time ticks at the usual rate, but calendar time can be sped up, slowed down, or frozen entirely. + * For maximum compatibility, all ScriptDate calls go to TimerGameEcomomy. */ +AIDate <- AIDateEconomy; + +AIBaseStation._GetConstructionDate <- AIBaseStation.GetConstructionDate; +AIBaseStation.GetConstructionDate <- function(station_id) +{ + if (!IsValidBaseStation(station_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::BaseStation::Get(station_id)->build_date.base(); +} + +AIEngine._GetDesignDate <- AIScriptEngine.GetDesignDate; +AIEngine.GetDesignDate <- function(engine_id) +{ + if (!IsValidEngine(engine_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::Engine::Get(engine_id)->intro_date.base(); +} diff --git a/bin/ai/compat_1.6.nut b/bin/ai/compat_1.6.nut index 91744512a7..e024138bc9 100644 --- a/bin/ai/compat_1.6.nut +++ b/bin/ai/compat_1.6.nut @@ -33,3 +33,23 @@ AIRoad.HasRoadType <- function(tile, road_type) } return false; } + +/* 14 splits date into calendar and economy time. Economy time ticks at the usual rate, but calendar time can be sped up, slowed down, or frozen entirely. + * For maximum compatibility, all ScriptDate calls go to TimerGameEcomomy. */ +AIDate <- AIDateEconomy; + +AIBaseStation._GetConstructionDate <- AIBaseStation.GetConstructionDate; +AIBaseStation.GetConstructionDate <- function(station_id) +{ + if (!IsValidBaseStation(station_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::BaseStation::Get(station_id)->build_date.base(); +} + +AIEngine._GetDesignDate <- AIScriptEngine.GetDesignDate; +AIEngine.GetDesignDate <- function(engine_id) +{ + if (!IsValidEngine(engine_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::Engine::Get(engine_id)->intro_date.base(); +} diff --git a/bin/ai/compat_1.7.nut b/bin/ai/compat_1.7.nut index 584a970f60..7d8560513e 100644 --- a/bin/ai/compat_1.7.nut +++ b/bin/ai/compat_1.7.nut @@ -33,3 +33,23 @@ AIRoad.HasRoadType <- function(tile, road_type) } return false; } + +/* 14 splits date into calendar and economy time. Economy time ticks at the usual rate, but calendar time can be sped up, slowed down, or frozen entirely. + * For maximum compatibility, all ScriptDate calls go to TimerGameEcomomy. */ +AIDate <- AIDateEconomy; + +AIBaseStation._GetConstructionDate <- AIBaseStation.GetConstructionDate; +AIBaseStation.GetConstructionDate <- function(station_id) +{ + if (!IsValidBaseStation(station_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::BaseStation::Get(station_id)->build_date.base(); +} + +AIEngine._GetDesignDate <- AIScriptEngine.GetDesignDate; +AIEngine.GetDesignDate <- function(engine_id) +{ + if (!IsValidEngine(engine_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::Engine::Get(engine_id)->intro_date.base(); +} diff --git a/bin/ai/compat_1.8.nut b/bin/ai/compat_1.8.nut index f57a0eab27..2b16da24f1 100644 --- a/bin/ai/compat_1.8.nut +++ b/bin/ai/compat_1.8.nut @@ -33,3 +33,23 @@ AIRoad.HasRoadType <- function(tile, road_type) } return false; } + +/* 14 splits date into calendar and economy time. Economy time ticks at the usual rate, but calendar time can be sped up, slowed down, or frozen entirely. + * For maximum compatibility, all ScriptDate calls go to TimerGameEcomomy. */ +AIDate <- AIDateEconomy; + +AIBaseStation._GetConstructionDate <- AIBaseStation.GetConstructionDate; +AIBaseStation.GetConstructionDate <- function(station_id) +{ + if (!IsValidBaseStation(station_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::BaseStation::Get(station_id)->build_date.base(); +} + +AIEngine._GetDesignDate <- AIScriptEngine.GetDesignDate; +AIEngine.GetDesignDate <- function(engine_id) +{ + if (!IsValidEngine(engine_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::Engine::Get(engine_id)->intro_date.base(); +} diff --git a/bin/ai/compat_1.9.nut b/bin/ai/compat_1.9.nut index 0dde6dc6da..798ee0da46 100644 --- a/bin/ai/compat_1.9.nut +++ b/bin/ai/compat_1.9.nut @@ -19,3 +19,23 @@ AIRoad.HasRoadType <- function(tile, road_type) } return false; } + +/* 14 splits date into calendar and economy time. Economy time ticks at the usual rate, but calendar time can be sped up, slowed down, or frozen entirely. + * For maximum compatibility, all ScriptDate calls go to TimerGameEcomomy. */ +AIDate <- AIDateEconomy; + +AIBaseStation._GetConstructionDate <- AIBaseStation.GetConstructionDate; +AIBaseStation.GetConstructionDate <- function(station_id) +{ + if (!IsValidBaseStation(station_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::BaseStation::Get(station_id)->build_date.base(); +} + +AIEngine._GetDesignDate <- AIScriptEngine.GetDesignDate; +AIEngine.GetDesignDate <- function(engine_id) +{ + if (!IsValidEngine(engine_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::Engine::Get(engine_id)->intro_date.base(); +} diff --git a/bin/ai/compat_12.nut b/bin/ai/compat_12.nut index d54895632f..fb950900b6 100644 --- a/bin/ai/compat_12.nut +++ b/bin/ai/compat_12.nut @@ -19,3 +19,23 @@ AIRoad.HasRoadType <- function(tile, road_type) } return false; } + +/* 14 splits date into calendar and economy time. Economy time ticks at the usual rate, but calendar time can be sped up, slowed down, or frozen entirely. + * For maximum compatibility, all ScriptDate calls go to TimerGameEcomomy. */ +AIDate <- AIDateEconomy; + +AIBaseStation._GetConstructionDate <- AIBaseStation.GetConstructionDate; +AIBaseStation.GetConstructionDate <- function(station_id) +{ + if (!IsValidBaseStation(station_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::BaseStation::Get(station_id)->build_date.base(); +} + +AIEngine._GetDesignDate <- AIScriptEngine.GetDesignDate; +AIEngine.GetDesignDate <- function(engine_id) +{ + if (!IsValidEngine(engine_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::Engine::Get(engine_id)->intro_date.base(); +} diff --git a/bin/ai/compat_13.nut b/bin/ai/compat_13.nut index 5f808e38a0..ed882cd768 100644 --- a/bin/ai/compat_13.nut +++ b/bin/ai/compat_13.nut @@ -6,3 +6,23 @@ */ AILog.Info("13 API compatibility in effect."); + +/* 14 splits date into calendar and economy time. Economy time ticks at the usual rate, but calendar time can be sped up, slowed down, or frozen entirely. + * For maximum compatibility, all ScriptDate calls go to TimerGameEcomomy. */ +AIDate <- AIDateEconomy; + +AIBaseStation._GetConstructionDate <- AIBaseStation.GetConstructionDate; +AIBaseStation.GetConstructionDate <- function(station_id) +{ + if (!IsValidBaseStation(station_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::BaseStation::Get(station_id)->build_date.base(); +} + +AIEngine._GetDesignDate <- AIScriptEngine.GetDesignDate; +AIEngine.GetDesignDate <- function(engine_id) +{ + if (!IsValidEngine(engine_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::Engine::Get(engine_id)->intro_date.base(); +} diff --git a/bin/game/compat_1.10.nut b/bin/game/compat_1.10.nut index 2559ff0a9c..f1e1978807 100644 --- a/bin/game/compat_1.10.nut +++ b/bin/game/compat_1.10.nut @@ -26,3 +26,55 @@ GSRoad.HasRoadType <- function(tile, road_type) } return false; } + +/* 14 splits date into calendar and economy time. Economy time ticks at the usual rate, but calendar time can be sped up, slowed down, or frozen entirely. + * This may break some scripts, but for maximum compatibility, all ScriptDate calls go to TimerGameEcomomy. */ +GSDate <- GSDateEconomy; + +GSBaseStation._GetConstructionDate <- GSBaseStation.GetConstructionDate; +GSBaseStation.GetConstructionDate <- function(station_id) +{ + if (!IsValidBaseStation(station_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::BaseStation::Get(station_id)->build_date.base(); +} + +GSClient._GetJoinDate <- GSClient.GetJoinDate; +GSClient.GetJoinDate <- function(client) +{ + NetworkClientInfo *ci = FindClientInfo(client); + if (ci == nullptr) return ScriptDateEconomy::DATE_INVALID; + return (ScriptDateEconomy::Date)ci->join_date.base(); +} + +GSEngine._GetDesignDate <- GSEngine.GetDesignDate; +GSEngine.GetDesignDate <- function(engine_id) +{ + if (!IsValidEngine(engine_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::Engine::Get(engine_id)->intro_date.base(); +} + +GSIndustry._GetConstructionDate <- GSIndustry.GetConstructionDate; +GSIndustry.GetConstructionDate <- function(industry_id) +{ + Industry *i = Industry::GetIfValid(industry_id); + if (i == nullptr) return ScriptDateEconomy::DATE_INVALID; + return (ScriptDateEconomy::Date)i->construction_date.base(); +} + +GSStoryPage._GetDate <- GSStoryPage.GetDate; +GSStoryPage.GetDate <- function(story_page_id) +{ + EnforcePrecondition(ScriptDateEconomy::DATE_INVALID, IsValidStoryPage(story_page_id)); + EnforceDeityMode(ScriptDateEconomy::DATE_INVALID); + return (ScriptDateEconomy::Date)StoryPage::Get(story_page_id)->date.base(); +} + +GSStoryPage._SetDate <- GSStoryPage.SetDate; +GSStoryPage.SetDate <- function(story_page_id, date) +{ + EnforcePrecondition(false, IsValidStoryPage(story_page_id)); + EnforceDeityMode(false); + return ScriptObject::Command::Do(story_page_id, date); +} diff --git a/bin/game/compat_1.11.nut b/bin/game/compat_1.11.nut index eac9a05d36..7178f438d4 100644 --- a/bin/game/compat_1.11.nut +++ b/bin/game/compat_1.11.nut @@ -19,3 +19,55 @@ GSRoad.HasRoadType <- function(tile, road_type) } return false; } + +/* 14 splits date into calendar and economy time. Economy time ticks at the usual rate, but calendar time can be sped up, slowed down, or frozen entirely. + * This may break some scripts, but for maximum compatibility, all ScriptDate calls go to TimerGameEcomomy. */ +GSDate <- GSDateEconomy; + +GSBaseStation._GetConstructionDate <- GSBaseStation.GetConstructionDate; +GSBaseStation.GetConstructionDate <- function(station_id) +{ + if (!IsValidBaseStation(station_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::BaseStation::Get(station_id)->build_date.base(); +} + +GSClient._GetJoinDate <- GSClient.GetJoinDate; +GSClient.GetJoinDate <- function(client) +{ + NetworkClientInfo *ci = FindClientInfo(client); + if (ci == nullptr) return ScriptDateEconomy::DATE_INVALID; + return (ScriptDateEconomy::Date)ci->join_date.base(); +} + +GSEngine._GetDesignDate <- GSEngine.GetDesignDate; +GSEngine.GetDesignDate <- function(engine_id) +{ + if (!IsValidEngine(engine_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::Engine::Get(engine_id)->intro_date.base(); +} + +GSIndustry._GetConstructionDate <- GSIndustry.GetConstructionDate; +GSIndustry.GetConstructionDate <- function(industry_id) +{ + Industry *i = Industry::GetIfValid(industry_id); + if (i == nullptr) return ScriptDateEconomy::DATE_INVALID; + return (ScriptDateEconomy::Date)i->construction_date.base(); +} + +GSStoryPage._GetDate <- GSStoryPage.GetDate; +GSStoryPage.GetDate <- function(story_page_id) +{ + EnforcePrecondition(ScriptDateEconomy::DATE_INVALID, IsValidStoryPage(story_page_id)); + EnforceDeityMode(ScriptDateEconomy::DATE_INVALID); + return (ScriptDateEconomy::Date)StoryPage::Get(story_page_id)->date.base(); +} + +GSStoryPage._SetDate <- GSStoryPage.SetDate; +GSStoryPage.SetDate <- function(story_page_id, date) +{ + EnforcePrecondition(false, IsValidStoryPage(story_page_id)); + EnforceDeityMode(false); + return ScriptObject::Command::Do(story_page_id, date); +} diff --git a/bin/game/compat_1.2.nut b/bin/game/compat_1.2.nut index 66e2ca5d62..c0895ae690 100644 --- a/bin/game/compat_1.2.nut +++ b/bin/game/compat_1.2.nut @@ -48,3 +48,55 @@ GSRoad.HasRoadType <- function(tile, road_type) } return false; } + +/* 14 splits date into calendar and economy time. Economy time ticks at the usual rate, but calendar time can be sped up, slowed down, or frozen entirely. + * This may break some scripts, but for maximum compatibility, all ScriptDate calls go to TimerGameEcomomy. */ +GSDate <- GSDateEconomy; + +GSBaseStation._GetConstructionDate <- GSBaseStation.GetConstructionDate; +GSBaseStation.GetConstructionDate <- function(station_id) +{ + if (!IsValidBaseStation(station_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::BaseStation::Get(station_id)->build_date.base(); +} + +GSClient._GetJoinDate <- GSClient.GetJoinDate; +GSClient.GetJoinDate <- function(client) +{ + NetworkClientInfo *ci = FindClientInfo(client); + if (ci == nullptr) return ScriptDateEconomy::DATE_INVALID; + return (ScriptDateEconomy::Date)ci->join_date.base(); +} + +GSEngine._GetDesignDate <- GSEngine.GetDesignDate; +GSEngine.GetDesignDate <- function(engine_id) +{ + if (!IsValidEngine(engine_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::Engine::Get(engine_id)->intro_date.base(); +} + +GSIndustry._GetConstructionDate <- GSIndustry.GetConstructionDate; +GSIndustry.GetConstructionDate <- function(industry_id) +{ + Industry *i = Industry::GetIfValid(industry_id); + if (i == nullptr) return ScriptDateEconomy::DATE_INVALID; + return (ScriptDateEconomy::Date)i->construction_date.base(); +} + +GSStoryPage._GetDate <- GSStoryPage.GetDate; +GSStoryPage.GetDate <- function(story_page_id) +{ + EnforcePrecondition(ScriptDateEconomy::DATE_INVALID, IsValidStoryPage(story_page_id)); + EnforceDeityMode(ScriptDateEconomy::DATE_INVALID); + return (ScriptDateEconomy::Date)StoryPage::Get(story_page_id)->date.base(); +} + +GSStoryPage._SetDate <- GSStoryPage.SetDate; +GSStoryPage.SetDate <- function(story_page_id, date) +{ + EnforcePrecondition(false, IsValidStoryPage(story_page_id)); + EnforceDeityMode(false); + return ScriptObject::Command::Do(story_page_id, date); +} diff --git a/bin/game/compat_1.3.nut b/bin/game/compat_1.3.nut index 9986ea03e5..bc0e35ce89 100644 --- a/bin/game/compat_1.3.nut +++ b/bin/game/compat_1.3.nut @@ -48,3 +48,55 @@ GSRoad.HasRoadType <- function(tile, road_type) } return false; } + +/* 14 splits date into calendar and economy time. Economy time ticks at the usual rate, but calendar time can be sped up, slowed down, or frozen entirely. + * This may break some scripts, but for maximum compatibility, all ScriptDate calls go to TimerGameEcomomy. */ +GSDate <- GSDateEconomy; + +GSBaseStation._GetConstructionDate <- GSBaseStation.GetConstructionDate; +GSBaseStation.GetConstructionDate <- function(station_id) +{ + if (!IsValidBaseStation(station_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::BaseStation::Get(station_id)->build_date.base(); +} + +GSClient._GetJoinDate <- GSClient.GetJoinDate; +GSClient.GetJoinDate <- function(client) +{ + NetworkClientInfo *ci = FindClientInfo(client); + if (ci == nullptr) return ScriptDateEconomy::DATE_INVALID; + return (ScriptDateEconomy::Date)ci->join_date.base(); +} + +GSEngine._GetDesignDate <- GSEngine.GetDesignDate; +GSEngine.GetDesignDate <- function(engine_id) +{ + if (!IsValidEngine(engine_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::Engine::Get(engine_id)->intro_date.base(); +} + +GSIndustry._GetConstructionDate <- GSIndustry.GetConstructionDate; +GSIndustry.GetConstructionDate <- function(industry_id) +{ + Industry *i = Industry::GetIfValid(industry_id); + if (i == nullptr) return ScriptDateEconomy::DATE_INVALID; + return (ScriptDateEconomy::Date)i->construction_date.base(); +} + +GSStoryPage._GetDate <- GSStoryPage.GetDate; +GSStoryPage.GetDate <- function(story_page_id) +{ + EnforcePrecondition(ScriptDateEconomy::DATE_INVALID, IsValidStoryPage(story_page_id)); + EnforceDeityMode(ScriptDateEconomy::DATE_INVALID); + return (ScriptDateEconomy::Date)StoryPage::Get(story_page_id)->date.base(); +} + +GSStoryPage._SetDate <- GSStoryPage.SetDate; +GSStoryPage.SetDate <- function(story_page_id, date) +{ + EnforcePrecondition(false, IsValidStoryPage(story_page_id)); + EnforceDeityMode(false); + return ScriptObject::Command::Do(story_page_id, date); +} diff --git a/bin/game/compat_1.4.nut b/bin/game/compat_1.4.nut index b3ec5c45cb..23713daffa 100644 --- a/bin/game/compat_1.4.nut +++ b/bin/game/compat_1.4.nut @@ -40,3 +40,55 @@ GSRoad.HasRoadType <- function(tile, road_type) } return false; } + +/* 14 splits date into calendar and economy time. Economy time ticks at the usual rate, but calendar time can be sped up, slowed down, or frozen entirely. + * This may break some scripts, but for maximum compatibility, all ScriptDate calls go to TimerGameEcomomy. */ +GSDate <- GSDateEconomy; + +GSBaseStation._GetConstructionDate <- GSBaseStation.GetConstructionDate; +GSBaseStation.GetConstructionDate <- function(station_id) +{ + if (!IsValidBaseStation(station_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::BaseStation::Get(station_id)->build_date.base(); +} + +GSClient._GetJoinDate <- GSClient.GetJoinDate; +GSClient.GetJoinDate <- function(client) +{ + NetworkClientInfo *ci = FindClientInfo(client); + if (ci == nullptr) return ScriptDateEconomy::DATE_INVALID; + return (ScriptDateEconomy::Date)ci->join_date.base(); +} + +GSEngine._GetDesignDate <- GSEngine.GetDesignDate; +GSEngine.GetDesignDate <- function(engine_id) +{ + if (!IsValidEngine(engine_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::Engine::Get(engine_id)->intro_date.base(); +} + +GSIndustry._GetConstructionDate <- GSIndustry.GetConstructionDate; +GSIndustry.GetConstructionDate <- function(industry_id) +{ + Industry *i = Industry::GetIfValid(industry_id); + if (i == nullptr) return ScriptDateEconomy::DATE_INVALID; + return (ScriptDateEconomy::Date)i->construction_date.base(); +} + +GSStoryPage._GetDate <- GSStoryPage.GetDate; +GSStoryPage.GetDate <- function(story_page_id) +{ + EnforcePrecondition(ScriptDateEconomy::DATE_INVALID, IsValidStoryPage(story_page_id)); + EnforceDeityMode(ScriptDateEconomy::DATE_INVALID); + return (ScriptDateEconomy::Date)StoryPage::Get(story_page_id)->date.base(); +} + +GSStoryPage._SetDate <- GSStoryPage.SetDate; +GSStoryPage.SetDate <- function(story_page_id, date) +{ + EnforcePrecondition(false, IsValidStoryPage(story_page_id)); + EnforceDeityMode(false); + return ScriptObject::Command::Do(story_page_id, date); +} diff --git a/bin/game/compat_1.5.nut b/bin/game/compat_1.5.nut index 2d25d7acf0..2740021328 100644 --- a/bin/game/compat_1.5.nut +++ b/bin/game/compat_1.5.nut @@ -33,3 +33,55 @@ GSRoad.HasRoadType <- function(tile, road_type) } return false; } + +/* 14 splits date into calendar and economy time. Economy time ticks at the usual rate, but calendar time can be sped up, slowed down, or frozen entirely. + * This may break some scripts, but for maximum compatibility, all ScriptDate calls go to TimerGameEcomomy. */ +GSDate <- GSDateEconomy; + +GSBaseStation._GetConstructionDate <- GSBaseStation.GetConstructionDate; +GSBaseStation.GetConstructionDate <- function(station_id) +{ + if (!IsValidBaseStation(station_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::BaseStation::Get(station_id)->build_date.base(); +} + +GSClient._GetJoinDate <- GSClient.GetJoinDate; +GSClient.GetJoinDate <- function(client) +{ + NetworkClientInfo *ci = FindClientInfo(client); + if (ci == nullptr) return ScriptDateEconomy::DATE_INVALID; + return (ScriptDateEconomy::Date)ci->join_date.base(); +} + +GSEngine._GetDesignDate <- GSEngine.GetDesignDate; +GSEngine.GetDesignDate <- function(engine_id) +{ + if (!IsValidEngine(engine_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::Engine::Get(engine_id)->intro_date.base(); +} + +GSIndustry._GetConstructionDate <- GSIndustry.GetConstructionDate; +GSIndustry.GetConstructionDate <- function(industry_id) +{ + Industry *i = Industry::GetIfValid(industry_id); + if (i == nullptr) return ScriptDateEconomy::DATE_INVALID; + return (ScriptDateEconomy::Date)i->construction_date.base(); +} + +GSStoryPage._GetDate <- GSStoryPage.GetDate; +GSStoryPage.GetDate <- function(story_page_id) +{ + EnforcePrecondition(ScriptDateEconomy::DATE_INVALID, IsValidStoryPage(story_page_id)); + EnforceDeityMode(ScriptDateEconomy::DATE_INVALID); + return (ScriptDateEconomy::Date)StoryPage::Get(story_page_id)->date.base(); +} + +GSStoryPage._SetDate <- GSStoryPage.SetDate; +GSStoryPage.SetDate <- function(story_page_id, date) +{ + EnforcePrecondition(false, IsValidStoryPage(story_page_id)); + EnforceDeityMode(false); + return ScriptObject::Command::Do(story_page_id, date); +} diff --git a/bin/game/compat_1.6.nut b/bin/game/compat_1.6.nut index d205832209..cb89baf385 100644 --- a/bin/game/compat_1.6.nut +++ b/bin/game/compat_1.6.nut @@ -33,3 +33,55 @@ GSRoad.HasRoadType <- function(tile, road_type) } return false; } + +/* 14 splits date into calendar and economy time. Economy time ticks at the usual rate, but calendar time can be sped up, slowed down, or frozen entirely. + * This may break some scripts, but for maximum compatibility, all ScriptDate calls go to TimerGameEcomomy. */ +GSDate <- GSDateEconomy; + +GSBaseStation._GetConstructionDate <- GSBaseStation.GetConstructionDate; +GSBaseStation.GetConstructionDate <- function(station_id) +{ + if (!IsValidBaseStation(station_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::BaseStation::Get(station_id)->build_date.base(); +} + +GSClient._GetJoinDate <- GSClient.GetJoinDate; +GSClient.GetJoinDate <- function(client) +{ + NetworkClientInfo *ci = FindClientInfo(client); + if (ci == nullptr) return ScriptDateEconomy::DATE_INVALID; + return (ScriptDateEconomy::Date)ci->join_date.base(); +} + +GSEngine._GetDesignDate <- GSEngine.GetDesignDate; +GSEngine.GetDesignDate <- function(engine_id) +{ + if (!IsValidEngine(engine_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::Engine::Get(engine_id)->intro_date.base(); +} + +GSIndustry._GetConstructionDate <- GSIndustry.GetConstructionDate; +GSIndustry.GetConstructionDate <- function(industry_id) +{ + Industry *i = Industry::GetIfValid(industry_id); + if (i == nullptr) return ScriptDateEconomy::DATE_INVALID; + return (ScriptDateEconomy::Date)i->construction_date.base(); +} + +GSStoryPage._GetDate <- GSStoryPage.GetDate; +GSStoryPage.GetDate <- function(story_page_id) +{ + EnforcePrecondition(ScriptDateEconomy::DATE_INVALID, IsValidStoryPage(story_page_id)); + EnforceDeityMode(ScriptDateEconomy::DATE_INVALID); + return (ScriptDateEconomy::Date)StoryPage::Get(story_page_id)->date.base(); +} + +GSStoryPage._SetDate <- GSStoryPage.SetDate; +GSStoryPage.SetDate <- function(story_page_id, date) +{ + EnforcePrecondition(false, IsValidStoryPage(story_page_id)); + EnforceDeityMode(false); + return ScriptObject::Command::Do(story_page_id, date); +} diff --git a/bin/game/compat_1.7.nut b/bin/game/compat_1.7.nut index 1108f41a7c..92d8a851b4 100644 --- a/bin/game/compat_1.7.nut +++ b/bin/game/compat_1.7.nut @@ -33,3 +33,55 @@ GSRoad.HasRoadType <- function(tile, road_type) } return false; } + +/* 14 splits date into calendar and economy time. Economy time ticks at the usual rate, but calendar time can be sped up, slowed down, or frozen entirely. + * This may break some scripts, but for maximum compatibility, all ScriptDate calls go to TimerGameEcomomy. */ +GSDate <- GSDateEconomy; + +GSBaseStation._GetConstructionDate <- GSBaseStation.GetConstructionDate; +GSBaseStation.GetConstructionDate <- function(station_id) +{ + if (!IsValidBaseStation(station_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::BaseStation::Get(station_id)->build_date.base(); +} + +GSClient._GetJoinDate <- GSClient.GetJoinDate; +GSClient.GetJoinDate <- function(client) +{ + NetworkClientInfo *ci = FindClientInfo(client); + if (ci == nullptr) return ScriptDateEconomy::DATE_INVALID; + return (ScriptDateEconomy::Date)ci->join_date.base(); +} + +GSEngine._GetDesignDate <- GSEngine.GetDesignDate; +GSEngine.GetDesignDate <- function(engine_id) +{ + if (!IsValidEngine(engine_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::Engine::Get(engine_id)->intro_date.base(); +} + +GSIndustry._GetConstructionDate <- GSIndustry.GetConstructionDate; +GSIndustry.GetConstructionDate <- function(industry_id) +{ + Industry *i = Industry::GetIfValid(industry_id); + if (i == nullptr) return ScriptDateEconomy::DATE_INVALID; + return (ScriptDateEconomy::Date)i->construction_date.base(); +} + +GSStoryPage._GetDate <- GSStoryPage.GetDate; +GSStoryPage.GetDate <- function(story_page_id) +{ + EnforcePrecondition(ScriptDateEconomy::DATE_INVALID, IsValidStoryPage(story_page_id)); + EnforceDeityMode(ScriptDateEconomy::DATE_INVALID); + return (ScriptDateEconomy::Date)StoryPage::Get(story_page_id)->date.base(); +} + +GSStoryPage._SetDate <- GSStoryPage.SetDate; +GSStoryPage.SetDate <- function(story_page_id, date) +{ + EnforcePrecondition(false, IsValidStoryPage(story_page_id)); + EnforceDeityMode(false); + return ScriptObject::Command::Do(story_page_id, date); +} diff --git a/bin/game/compat_1.8.nut b/bin/game/compat_1.8.nut index 139f91214b..cd37777631 100644 --- a/bin/game/compat_1.8.nut +++ b/bin/game/compat_1.8.nut @@ -33,3 +33,55 @@ GSRoad.HasRoadType <- function(tile, road_type) } return false; } + +/* 14 splits date into calendar and economy time. Economy time ticks at the usual rate, but calendar time can be sped up, slowed down, or frozen entirely. + * This may break some scripts, but for maximum compatibility, all ScriptDate calls go to TimerGameEcomomy. */ +GSDate <- GSDateEconomy; + +GSBaseStation._GetConstructionDate <- GSBaseStation.GetConstructionDate; +GSBaseStation.GetConstructionDate <- function(station_id) +{ + if (!IsValidBaseStation(station_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::BaseStation::Get(station_id)->build_date.base(); +} + +GSClient._GetJoinDate <- GSClient.GetJoinDate; +GSClient.GetJoinDate <- function(client) +{ + NetworkClientInfo *ci = FindClientInfo(client); + if (ci == nullptr) return ScriptDateEconomy::DATE_INVALID; + return (ScriptDateEconomy::Date)ci->join_date.base(); +} + +GSEngine._GetDesignDate <- GSEngine.GetDesignDate; +GSEngine.GetDesignDate <- function(engine_id) +{ + if (!IsValidEngine(engine_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::Engine::Get(engine_id)->intro_date.base(); +} + +GSIndustry._GetConstructionDate <- GSIndustry.GetConstructionDate; +GSIndustry.GetConstructionDate <- function(industry_id) +{ + Industry *i = Industry::GetIfValid(industry_id); + if (i == nullptr) return ScriptDateEconomy::DATE_INVALID; + return (ScriptDateEconomy::Date)i->construction_date.base(); +} + +GSStoryPage._GetDate <- GSStoryPage.GetDate; +GSStoryPage.GetDate <- function(story_page_id) +{ + EnforcePrecondition(ScriptDateEconomy::DATE_INVALID, IsValidStoryPage(story_page_id)); + EnforceDeityMode(ScriptDateEconomy::DATE_INVALID); + return (ScriptDateEconomy::Date)StoryPage::Get(story_page_id)->date.base(); +} + +GSStoryPage._SetDate <- GSStoryPage.SetDate; +GSStoryPage.SetDate <- function(story_page_id, date) +{ + EnforcePrecondition(false, IsValidStoryPage(story_page_id)); + EnforceDeityMode(false); + return ScriptObject::Command::Do(story_page_id, date); +} diff --git a/bin/game/compat_1.9.nut b/bin/game/compat_1.9.nut index 053e377d4c..1d080976df 100644 --- a/bin/game/compat_1.9.nut +++ b/bin/game/compat_1.9.nut @@ -26,3 +26,55 @@ GSRoad.HasRoadType <- function(tile, road_type) } return false; } + +/* 14 splits date into calendar and economy time. Economy time ticks at the usual rate, but calendar time can be sped up, slowed down, or frozen entirely. + * This may break some scripts, but for maximum compatibility, all ScriptDate calls go to TimerGameEcomomy. */ +GSDate <- GSDateEconomy; + +GSBaseStation._GetConstructionDate <- GSBaseStation.GetConstructionDate; +GSBaseStation.GetConstructionDate <- function(station_id) +{ + if (!IsValidBaseStation(station_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::BaseStation::Get(station_id)->build_date.base(); +} + +GSClient._GetJoinDate <- GSClient.GetJoinDate; +GSClient.GetJoinDate <- function(client) +{ + NetworkClientInfo *ci = FindClientInfo(client); + if (ci == nullptr) return ScriptDateEconomy::DATE_INVALID; + return (ScriptDateEconomy::Date)ci->join_date.base(); +} + +GSEngine._GetDesignDate <- GSEngine.GetDesignDate; +GSEngine.GetDesignDate <- function(engine_id) +{ + if (!IsValidEngine(engine_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::Engine::Get(engine_id)->intro_date.base(); +} + +GSIndustry._GetConstructionDate <- GSIndustry.GetConstructionDate; +GSIndustry.GetConstructionDate <- function(industry_id) +{ + Industry *i = Industry::GetIfValid(industry_id); + if (i == nullptr) return ScriptDateEconomy::DATE_INVALID; + return (ScriptDateEconomy::Date)i->construction_date.base(); +} + +GSStoryPage._GetDate <- GSStoryPage.GetDate; +GSStoryPage.GetDate <- function(story_page_id) +{ + EnforcePrecondition(ScriptDateEconomy::DATE_INVALID, IsValidStoryPage(story_page_id)); + EnforceDeityMode(ScriptDateEconomy::DATE_INVALID); + return (ScriptDateEconomy::Date)StoryPage::Get(story_page_id)->date.base(); +} + +GSStoryPage._SetDate <- GSStoryPage.SetDate; +GSStoryPage.SetDate <- function(story_page_id, date) +{ + EnforcePrecondition(false, IsValidStoryPage(story_page_id)); + EnforceDeityMode(false); + return ScriptObject::Command::Do(story_page_id, date); +} diff --git a/bin/game/compat_12.nut b/bin/game/compat_12.nut index a11cd04a23..5dad976384 100644 --- a/bin/game/compat_12.nut +++ b/bin/game/compat_12.nut @@ -19,3 +19,55 @@ GSRoad.HasRoadType <- function(tile, road_type) } return false; } + +/* 14 splits date into calendar and economy time. Economy time ticks at the usual rate, but calendar time can be sped up, slowed down, or frozen entirely. + * This may break some scripts, but for maximum compatibility, all ScriptDate calls go to TimerGameEcomomy. */ +GSDate <- GSDateEconomy; + +GSBaseStation._GetConstructionDate <- GSBaseStation.GetConstructionDate; +GSBaseStation.GetConstructionDate <- function(station_id) +{ + if (!IsValidBaseStation(station_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::BaseStation::Get(station_id)->build_date.base(); +} + +GSClient._GetJoinDate <- GSClient.GetJoinDate; +GSClient.GetJoinDate <- function(client) +{ + NetworkClientInfo *ci = FindClientInfo(client); + if (ci == nullptr) return ScriptDateEconomy::DATE_INVALID; + return (ScriptDateEconomy::Date)ci->join_date.base(); +} + +GSEngine._GetDesignDate <- GSEngine.GetDesignDate; +GSEngine.GetDesignDate <- function(engine_id) +{ + if (!IsValidEngine(engine_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::Engine::Get(engine_id)->intro_date.base(); +} + +GSIndustry._GetConstructionDate <- GSIndustry.GetConstructionDate; +GSIndustry.GetConstructionDate <- function(industry_id) +{ + Industry *i = Industry::GetIfValid(industry_id); + if (i == nullptr) return ScriptDateEconomy::DATE_INVALID; + return (ScriptDateEconomy::Date)i->construction_date.base(); +} + +GSStoryPage._GetDate <- GSStoryPage.GetDate; +GSStoryPage.GetDate <- function(story_page_id) +{ + EnforcePrecondition(ScriptDateEconomy::DATE_INVALID, IsValidStoryPage(story_page_id)); + EnforceDeityMode(ScriptDateEconomy::DATE_INVALID); + return (ScriptDateEconomy::Date)StoryPage::Get(story_page_id)->date.base(); +} + +GSStoryPage._SetDate <- GSStoryPage.SetDate; +GSStoryPage.SetDate <- function(story_page_id, date) +{ + EnforcePrecondition(false, IsValidStoryPage(story_page_id)); + EnforceDeityMode(false); + return ScriptObject::Command::Do(story_page_id, date); +} diff --git a/bin/game/compat_13.nut b/bin/game/compat_13.nut index 0ee9faf2bd..c738113d4a 100644 --- a/bin/game/compat_13.nut +++ b/bin/game/compat_13.nut @@ -6,3 +6,55 @@ */ GSLog.Info("13 API compatibility in effect."); + +/* 14 splits date into calendar and economy time. Economy time ticks at the usual rate, but calendar time can be sped up, slowed down, or frozen entirely. + * This may break some scripts, but for maximum compatibility, all ScriptDate calls go to TimerGameEcomomy. */ +GSDate <- GSDateEconomy; + +GSBaseStation._GetConstructionDate <- GSBaseStation.GetConstructionDate; +GSBaseStation.GetConstructionDate <- function(station_id) +{ + if (!IsValidBaseStation(station_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::BaseStation::Get(station_id)->build_date.base(); +} + +GSClient._GetJoinDate <- GSClient.GetJoinDate; +GSClient.GetJoinDate <- function(client) +{ + NetworkClientInfo *ci = FindClientInfo(client); + if (ci == nullptr) return ScriptDateEconomy::DATE_INVALID; + return (ScriptDateEconomy::Date)ci->join_date.base(); +} + +GSEngine._GetDesignDate <- GSEngine.GetDesignDate; +GSEngine.GetDesignDate <- function(engine_id) +{ + if (!IsValidEngine(engine_id)) return ScriptDateEconomy::DATE_INVALID; + + return (ScriptDateEconomy::Date)::Engine::Get(engine_id)->intro_date.base(); +} + +GSIndustry._GetConstructionDate <- GSIndustry.GetConstructionDate; +GSIndustry.GetConstructionDate <- function(industry_id) +{ + Industry *i = Industry::GetIfValid(industry_id); + if (i == nullptr) return ScriptDateEconomy::DATE_INVALID; + return (ScriptDateEconomy::Date)i->construction_date.base(); +} + +GSStoryPage._GetDate <- GSStoryPage.GetDate; +GSStoryPage.GetDate <- function(story_page_id) +{ + EnforcePrecondition(ScriptDateEconomy::DATE_INVALID, IsValidStoryPage(story_page_id)); + EnforceDeityMode(ScriptDateEconomy::DATE_INVALID); + return (ScriptDateEconomy::Date)StoryPage::Get(story_page_id)->date.base(); +} + +GSStoryPage._SetDate <- GSStoryPage.SetDate; +GSStoryPage.SetDate <- function(story_page_id, date) +{ + EnforcePrecondition(false, IsValidStoryPage(story_page_id)); + EnforceDeityMode(false); + return ScriptObject::Command::Do(story_page_id, date); +} diff --git a/src/script/api/ai_changelog.hpp b/src/script/api/ai_changelog.hpp index 3b47ad0424..6b4a90689f 100644 --- a/src/script/api/ai_changelog.hpp +++ b/src/script/api/ai_changelog.hpp @@ -17,6 +17,10 @@ * * This version is not yet released. The following changes are not set in stone yet. * + * Major API changes: + * \li All AIDate:: functions are split into AIDateCalendar and AIDateEconomy classes and mirrored in both. The exception is AIDate::GetSystemTime, which only exists in AIDateEconomy. + * \li Compatibility layers for AIDate:: map all functions to AIDateEconomy to break the fewest number of scripts possible. We apologize for any broken scripts. :( + * * API additions: * \li GSIndustry::GetConstructionDate * \li GSAsyncMode diff --git a/src/script/api/game_changelog.hpp b/src/script/api/game_changelog.hpp index c07b89cf8b..ee7fdaf490 100644 --- a/src/script/api/game_changelog.hpp +++ b/src/script/api/game_changelog.hpp @@ -17,6 +17,10 @@ * * This version is not yet released. The following changes are not set in stone yet. * + * Major API changes: + * \li All GSDate:: functions are split into GSDateCalendar and GSDateEconomy classes and mirrored in both. The exception is GSDate::GetSystemTime, which only exists in GSDateEconomy. + * \li Compatibility layers for GSDate:: map all functions to GSDateEconomy to break the fewest number of scripts possible. We apologize for any broken scripts. :( + * * API additions: * \li GSIndustry::GetConstructionDate * \li GSAsyncMode