Dayz 1.25
Dayz Code Explorer by KGB
Загрузка...
Поиск...
Не найдено
Защищенные члены | Защищенные данные | Статические защищенные данные | Закрытые данные
Класс WorldData

Keeps information about currently loaded world, like temperature. Подробнее...

Защищенные члены

void WorldData ()
 
void Init ()
 
float GetApproxSunriseTime (float monthday)
 
float GetApproxSunsetTime (float monthday)
 
float CalcBaseEnvironmentTemperature (float monthday, float daytime)
 
void UpdateBaseEnvTemperature (float timeslice)
 
float GetBaseEnvTemperature ()
 
float GetBaseEnvTemperatureExact (int month, int day, int hour, int minute)
 
float GetDayTemperature ()
 
float GetNightTemperature ()
 
bool WeatherOnBeforeChange (EWeatherPhenomenon type, float actual, float change, float time)
 
array< vector > GetArtyFiringPos ()
 
void BaseTempDebug (int month, int day)
 
override void Init ()
 
override bool WeatherOnBeforeChange (EWeatherPhenomenon type, float actual, float change, float time)
 
override void Init ()
 
override bool WeatherOnBeforeChange (EWeatherPhenomenon type, float actual, float change, float time)
 

Защищенные данные

float m_DayTemperature
 
float m_NightTemperature
 
Weather m_Weather
 
float m_EnvironmentTemperature
 
float m_Timer
 
float m_MaxTemps [12]
 
float m_MinTemps [12]
 
float m_Sunrise_Jan
 
float m_Sunset_Jan
 
float m_Sunrise_Jul
 
float m_Sunset_Jul
 
ref array< vector > m_FiringPos
 
int m_clearWeatherChance = CLEAR_WEATHER_CHANCE
 
int m_badWeatherChance = BAD_WEATHER_CHANCE
 
int m_sameWeatherCnt = 0
 
int m_stepValue = 5
 
int m_chance = 50
 
int m_choosenWeather = 1
 
int m_lastWeather = 0
 

Статические защищенные данные

static const ref array< vector > CHERNARUS_ARTY_STRIKE_POS
 
static const ref array< vector > LIVONIA_ARTY_STRIKE_POS
 

Закрытые данные

const float RAIN_THRESHOLD = 0.6
 
const float STORM_THRESHOLD = 0.9
 
const int OVERCAST_MIN_TIME = 600
 
const int OVERCAST_MAX_TIME = 900
 
const int RAIN_TIME_MIN = 60
 
const int RAIN_TIME_MAX = 120
 
const int CLEAR_WEATHER = 1
 
const int CLOUDY_WEATHER = 2
 
const int BAD_WEATHER = 3
 
const int CLEAR_WEATHER_CHANCE = 30
 
const int BAD_WEATHER_CHANCE = 80
 

Подробное описание

Keeps information about currently loaded world, like temperature.

Конструктор(ы)

◆ WorldData()

void WorldData ( )
inlineprotected
18 {
19 Init();
20 }
WorldData::Init
void Init()
Definition WorldData.c:22

Перекрестные ссылки Init().

Методы

◆ BaseTempDebug()

void BaseTempDebug ( int month,
int day )
inlineprotected
140 {
141 Print("--------------------");
142 for ( int i = 0; i < 24; i++ )
143 {
144 for ( int j = 0; j < 6; j++ )
145 {
146 int minute = ( j * 10 );
147 Print(string.Format( "%1:%2 %3", i, minute, GetBaseEnvTemperatureExact( month, day, i, minute ) ) );
148 }
149 }
150 }
Param3
Definition EntityAI.c:95
WorldData::GetBaseEnvTemperatureExact
float GetBaseEnvTemperatureExact(int month, int day, int hour, int minute)
Definition WorldData.c:110
Print
proto void Print(void var)
Prints content of variable to console/log.

Перекрестные ссылки GetBaseEnvTemperatureExact() и Print().

◆ CalcBaseEnvironmentTemperature()

float CalcBaseEnvironmentTemperature ( float monthday,
float daytime )
inlineprotected
52 {
53 float approxSunrise = GetApproxSunriseTime( monthday );
54 float approxSunset = GetApproxSunsetTime( monthday );
55 float dayLight = approxSunset - approxSunrise;
56 float nightTime = 24.0 - dayLight;
57 int tempArrayIndex = Math.Floor(monthday) - 1;
58 int tempArrayIndexToLerp = tempArrayIndex + 1;
59 if ( tempArrayIndexToLerp >= 12 )
60 tempArrayIndexToLerp = 0;
61 float tempArrayLerp = monthday - Math.Floor(monthday);
62 float minTempA = m_MinTemps[tempArrayIndex];
63 float minTempB = m_MinTemps[tempArrayIndexToLerp];
64 float maxTempA = m_MaxTemps[tempArrayIndex];
65 float maxTempB = m_MaxTemps[tempArrayIndexToLerp];
66 float eveningMinA = minTempA + ( 0.5 * Math.AbsFloat( minTempA - maxTempA ) );
67 float eveningMinB = minTempB + ( 0.5 * Math.AbsFloat( minTempB - maxTempB ) );
68
69 if ( ( daytime >= approxSunrise ) && ( daytime <= approxSunset ) ) {
70 if ( daytime <= ( approxSunrise + ( dayLight * 0.75 ) ) )
71 return Math.Lerp(
72 Math.Lerp( minTempA, minTempB, tempArrayLerp ),
73 Math.Lerp( maxTempA, maxTempB, tempArrayLerp ),
74 ( ( daytime - approxSunrise ) / ( dayLight * 0.75 ) ) );
75 else
76 return Math.Lerp(
77 Math.Lerp( maxTempA, maxTempB, tempArrayLerp ),
78 Math.Lerp( eveningMinA, eveningMinB, tempArrayLerp ),
79 ( ( ( daytime - approxSunrise ) - ( dayLight * 0.75 ) ) / ( dayLight - ( dayLight * 0.75 ) ) ) );
80 } else {
81 if ( ( daytime > approxSunset ) && ( daytime < 24 ) )
82 return Math.Lerp(
83 Math.Lerp( eveningMinA, eveningMinB, tempArrayLerp ),
84 Math.Lerp( minTempA, minTempB, tempArrayLerp ),
85 ( ( daytime - approxSunset ) / ( 24 - approxSunset ) ) / 2.0 );
86 else
87 return Math.Lerp(
88 Math.Lerp( eveningMinA, eveningMinB, tempArrayLerp ),
89 Math.Lerp( minTempA, minTempB, tempArrayLerp ),
90 ( ( ( daytime + ( 24 - approxSunset ) ) / nightTime ) / 2.0 ) + 0.5 );
91 }
92 }
Math
Definition EnMath.c:7
WorldData::GetApproxSunsetTime
float GetApproxSunsetTime(float monthday)
Definition WorldData.c:44
WorldData::m_MaxTemps
float m_MaxTemps[12]
Definition WorldData.c:9
WorldData::GetApproxSunriseTime
float GetApproxSunriseTime(float monthday)
Definition WorldData.c:37
WorldData::m_MinTemps
float m_MinTemps[12]
Definition WorldData.c:10
Math::Lerp
static proto float Lerp(float a, float b, float time)
Linearly interpolates between 'a' and 'b' given 'time'.
Math::AbsFloat
static proto float AbsFloat(float f)
Returns absolute value.
Math::Floor
static proto float Floor(float f)
Returns floor of value.

Перекрестные ссылки Math::AbsFloat(), Math::Floor(), GetApproxSunriseTime(), GetApproxSunsetTime(), Math::Lerp(), m_MaxTemps и m_MinTemps.

Используется в GetBaseEnvTemperatureExact() и UpdateBaseEnvTemperature().

◆ GetApproxSunriseTime()

float GetApproxSunriseTime ( float monthday)
inlineprotected
38 {
39 if ( monthday <= 8.0 )
40 return ( ( m_Sunrise_Jan - m_Sunrise_Jul ) / ( 8 - 1 ) ) * ( 1 - monthday ) + m_Sunrise_Jan;
41 else
42 return ( ( ( monthday - 8 ) * ( m_Sunrise_Jan - m_Sunrise_Jul ) ) / ( 13 - 8 ) ) + m_Sunrise_Jul;
43 }
WorldData::m_Sunrise_Jan
float m_Sunrise_Jan
Definition WorldData.c:11
WorldData::m_Sunrise_Jul
float m_Sunrise_Jul
Definition WorldData.c:13

Перекрестные ссылки m_Sunrise_Jan и m_Sunrise_Jul.

Используется в CalcBaseEnvironmentTemperature().

◆ GetApproxSunsetTime()

float GetApproxSunsetTime ( float monthday)
inlineprotected
45 {
46 if ( monthday <= 8.0 )
47 return ( ( m_Sunset_Jan - m_Sunset_Jul ) / (8 - 1) ) * ( 1 - monthday ) + m_Sunset_Jan;
48 else
49 return ( ( ( monthday - 8 ) * ( m_Sunset_Jan - m_Sunset_Jul ) ) / ( 13 - 8 ) ) + m_Sunset_Jul;
50 }
WorldData::m_Sunset_Jul
float m_Sunset_Jul
Definition WorldData.c:14
WorldData::m_Sunset_Jan
float m_Sunset_Jan
Definition WorldData.c:12

Перекрестные ссылки m_Sunset_Jan и m_Sunset_Jul.

Используется в CalcBaseEnvironmentTemperature().

◆ GetArtyFiringPos()

array< vector > GetArtyFiringPos ( )
inlineprotected
134 {
135 return m_FiringPos;
136 }
WorldData::m_FiringPos
ref array< vector > m_FiringPos
Definition WorldData.c:15

Перекрестные ссылки m_FiringPos.

◆ GetBaseEnvTemperature()

float GetBaseEnvTemperature ( )
inlineprotected
107 {
108 return m_EnvironmentTemperature;
109 }
WorldData::m_EnvironmentTemperature
float m_EnvironmentTemperature
Definition WorldData.c:7

Перекрестные ссылки m_EnvironmentTemperature.

◆ GetBaseEnvTemperatureExact()

float GetBaseEnvTemperatureExact ( int month,
int day,
int hour,
int minute )
inlineprotected
111 {
112 return CalcBaseEnvironmentTemperature( month + ( day / 32.0 ), hour + ( minute / 60.0 ) );
113 }
WorldData::CalcBaseEnvironmentTemperature
float CalcBaseEnvironmentTemperature(float monthday, float daytime)
Definition WorldData.c:51

Перекрестные ссылки CalcBaseEnvironmentTemperature().

Используется в BaseTempDebug().

◆ GetDayTemperature()

float GetDayTemperature ( )
inlineprotected
117 {
118 return m_DayTemperature;
119 }
WorldData::m_DayTemperature
float m_DayTemperature
Definition WorldData.c:4

Перекрестные ссылки m_DayTemperature.

◆ GetNightTemperature()

float GetNightTemperature ( )
inlineprotected
122 {
123 return m_NightTemperature;
124 }
WorldData::m_NightTemperature
float m_NightTemperature
Definition WorldData.c:5

Перекрестные ссылки m_NightTemperature.

◆ Init() [1/3]

void Init ( )
inlineprotected
23 {
24 m_DayTemperature = 10; // legacy, no longer used
25 m_NightTemperature = 6; // legacy, no longer used
26 m_Weather = g_Game.GetWeather();
27 m_EnvironmentTemperature = 12.0;
28 m_Timer = 0.0;
29 m_Sunrise_Jan = 8.54;
30 m_Sunset_Jan = 15.52;
31 m_Sunrise_Jul = 3.26;
32 m_Sunset_Jul = 20.73;
33 m_MaxTemps = {3,5,7,14,19,24,26,25,21,16,10,5};
34 m_MinTemps = {-3,-2,0,4,9,14,18,17,12,7,4,0};
35 }
g_Game
DayZGame g_Game
Definition DayZGame.c:3746
WorldData::m_Timer
float m_Timer
Definition WorldData.c:8
WorldData::m_Weather
Weather m_Weather
Definition WorldData.c:6

Перекрестные ссылки g_Game, m_DayTemperature, m_EnvironmentTemperature, m_MaxTemps, m_MinTemps, m_NightTemperature, m_Sunrise_Jan, m_Sunrise_Jul, m_Sunset_Jan, m_Sunset_Jul, m_Timer и m_Weather.

Используется в WorldData().

◆ Init() [2/3]

override void Init ( )
inlineprotected
42 {
43 super.Init();
44
45 // new temperature curve settings
46 m_Sunrise_Jan = 8.54;
47 m_Sunset_Jan = 15.52;
48 m_Sunrise_Jul = 3.26;
49 m_Sunset_Jul = 20.73;
50
51 int tempIdx;
52 m_MinTemps = {-3,-2,0,4,9,14,18,17,12,7,4,0};
53 if (CfgGameplayHandler.GetEnvironmentMinTemps() && CfgGameplayHandler.GetEnvironmentMinTemps().Count() == 12)
54 {
55 for (tempIdx = 0; tempIdx < CfgGameplayHandler.GetEnvironmentMinTemps().Count(); tempIdx++)
56 {
57 m_MinTemps[tempIdx] = CfgGameplayHandler.GetEnvironmentMinTemps().Get(tempIdx);
58 }
59 }
60
61 m_MaxTemps = {3,5,7,14,19,24,26,25,21,16,10,5};
62 if (CfgGameplayHandler.GetEnvironmentMaxTemps() && CfgGameplayHandler.GetEnvironmentMaxTemps().Count() == 12)
63 {
64 for (tempIdx = 0; tempIdx < CfgGameplayHandler.GetEnvironmentMaxTemps().Count(); tempIdx++)
65 {
66 m_MaxTemps[tempIdx] = CfgGameplayHandler.GetEnvironmentMaxTemps().Get(tempIdx);
67 }
68 }
69
70 m_FiringPos = CHERNARUS_ARTY_STRIKE_POS;
71 }
Count
@ Count
Definition RandomGeneratorSyncManager.c:7
CfgGameplayHandler
Definition CfgGameplayHandler.c:2
CfgGameplayHandler::GetEnvironmentMinTemps
static array< float > GetEnvironmentMinTemps()
Definition CfgGameplayHandler.c:146
CfgGameplayHandler::GetEnvironmentMaxTemps
static array< float > GetEnvironmentMaxTemps()
Definition CfgGameplayHandler.c:151
WorldData::CHERNARUS_ARTY_STRIKE_POS
static const ref array< vector > CHERNARUS_ARTY_STRIKE_POS
Definition ChernarusPlus.c:32

Перекрестные ссылки Count, CfgGameplayHandler::GetEnvironmentMaxTemps() и CfgGameplayHandler::GetEnvironmentMinTemps().

◆ Init() [3/3]

override void Init ( )
inlineprotected
44 {
45 super.Init();
46
47 // new temperature curve settings
48 m_Sunrise_Jan = 8.4;
49 m_Sunset_Jan = 15.63;
50 m_Sunrise_Jul = 3.65;
51 m_Sunset_Jul = 20.35;
52
53 int tempIdx;
54 m_MinTemps = {-7,-7.4,-4.1,1.5,7,11.3,13.4,13.1,9.3,5.3,0.8,-3.6};
55 if (CfgGameplayHandler.GetEnvironmentMinTemps() && CfgGameplayHandler.GetEnvironmentMinTemps().Count() == 12)
56 {
57 for (tempIdx = 0; tempIdx < CfgGameplayHandler.GetEnvironmentMinTemps().Count(); tempIdx++)
58 {
59 m_MinTemps[tempIdx] = CfgGameplayHandler.GetEnvironmentMinTemps().Get(tempIdx);
60 }
61 }
62
63 m_MaxTemps = {-2.5,-2.1,2.3,9,15.5,19.4,20.9,20.4,16,10.5,4.2,0.1};
64 if (CfgGameplayHandler.GetEnvironmentMaxTemps() && CfgGameplayHandler.GetEnvironmentMaxTemps().Count() == 12)
65 {
66 for (tempIdx = 0; tempIdx < CfgGameplayHandler.GetEnvironmentMaxTemps().Count(); tempIdx++)
67 {
68 m_MaxTemps[tempIdx] = CfgGameplayHandler.GetEnvironmentMaxTemps().Get(tempIdx);
69 }
70 }
71
72 m_FiringPos = LIVONIA_ARTY_STRIKE_POS;
73 }
WorldData::LIVONIA_ARTY_STRIKE_POS
static const ref array< vector > LIVONIA_ARTY_STRIKE_POS
Definition Enoch.c:31

Перекрестные ссылки Count, CfgGameplayHandler::GetEnvironmentMaxTemps() и CfgGameplayHandler::GetEnvironmentMinTemps().

◆ UpdateBaseEnvTemperature()

void UpdateBaseEnvTemperature ( float timeslice)
inlineprotected
94 {
95 m_Timer += timeslice;
96 if ( m_Timer > 30 )
97 {
98 int year, month, day, hour, minute;
99 GetGame().GetWorld().GetDate( year, month, day, hour, minute );
100 m_EnvironmentTemperature = CalcBaseEnvironmentTemperature( month + ( day / 32.0 ), hour + ( minute / 60.0 ) );
101 m_Timer = 0;
102 }
103 }
GetGame
proto native CGame GetGame()

Перекрестные ссылки CalcBaseEnvironmentTemperature(), GetGame(), m_EnvironmentTemperature и m_Timer.

◆ WeatherOnBeforeChange() [1/3]

bool WeatherOnBeforeChange ( EWeatherPhenomenon type,
float actual,
float change,
float time )
inlineprotected
127 {
128 // default behaviour is same like setting MissionWeather (in Weather) to true
129 return false;
130 }

◆ WeatherOnBeforeChange() [2/3]

override bool WeatherOnBeforeChange ( EWeatherPhenomenon type,
float actual,
float change,
float time )
inlineprotected
74 {
75 int phmnTime = 5;
76 int phmnLength = 10;
77 float phmnValue = 0;
78
79 m_Weather.SetStorm( 1.0, STORM_THRESHOLD, 45 );
80
81 m_Weather.SetRainThresholds( 0.0, 1.0, 60 );
82 m_Weather.SetWindMaximumSpeed( 20 );
83 m_Weather.SetWindFunctionParams( 0.1, 1.0, 20 );
84
85 switch (type)
86 {
87 //-----------------------------------------------------------------------------------------------------------------------------
88 case EWeatherPhenomenon.OVERCAST:
89
90 //went something goes wrong choose some default random weather
91 phmnValue = Math.RandomFloatInclusive( 0.2, 0.7 );
92 phmnTime = Math.RandomIntInclusive( OVERCAST_MIN_TIME, OVERCAST_MAX_TIME );
93 phmnLength = Math.RandomIntInclusive( OVERCAST_MIN_TIME, OVERCAST_MAX_TIME );
94
95 //----
96 //calculate next weather
97 m_chance = Math.RandomIntInclusive( 0, 100 );
98
99 //--
100 if ( m_lastWeather == CLEAR_WEATHER )
101 {
102 m_clearWeatherChance -= ( m_stepValue * m_sameWeatherCnt); //decrease the chance of the same weather
103 }
104
105 if ( m_lastWeather == CLOUDY_WEATHER )
106 {
107 m_clearWeatherChance += ( m_stepValue * m_sameWeatherCnt); //increase the chance of the better weather
108 //m_badWeatherChance += ( m_stepValue * m_sameWeatherCnt);
109 }
110
111 if ( m_lastWeather == BAD_WEATHER )
112 {
113 m_clearWeatherChance += m_stepValue; //increase the chance of the better weather slightly
114 m_badWeatherChance += (( m_stepValue * m_sameWeatherCnt ) + m_stepValue ); //decrease the chance of the same weather rapidly
115 }
116
117 //----
118 if ( m_chance < m_clearWeatherChance )
119 {
120 m_choosenWeather = CLEAR_WEATHER;
121 if ( m_lastWeather == CLEAR_WEATHER )
122 m_sameWeatherCnt ++;
123 }
124 else if ( m_chance > m_badWeatherChance )
125 {
126 m_choosenWeather = BAD_WEATHER;
127 if ( m_lastWeather == BAD_WEATHER )
128 m_sameWeatherCnt ++;
129 }
130 else
131 {
132 m_choosenWeather = CLOUDY_WEATHER;
133 if ( m_lastWeather == CLOUDY_WEATHER )
134 m_sameWeatherCnt ++;
135 }
136
137 if ( m_choosenWeather != m_lastWeather )
138 m_sameWeatherCnt = 0;
139
140 m_clearWeatherChance = CLEAR_WEATHER_CHANCE;
141 m_badWeatherChance = BAD_WEATHER_CHANCE;
142
143 //----
144 //set choosen weather
145 if ( m_choosenWeather == CLEAR_WEATHER )
146 {
147 m_lastWeather = CLEAR_WEATHER;
148
149 phmnValue = Math.RandomFloatInclusive( 0.0, 0.3 );
150 phmnTime = Math.RandomIntInclusive( OVERCAST_MIN_TIME, OVERCAST_MAX_TIME );
151 phmnLength = Math.RandomIntInclusive( OVERCAST_MIN_TIME, OVERCAST_MAX_TIME );
152 }
153
154 if ( m_choosenWeather == CLOUDY_WEATHER )
155 {
156 m_lastWeather = CLOUDY_WEATHER;
157
158 phmnValue = Math.RandomFloatInclusive( 0.3, 0.6 );
159 phmnTime = Math.RandomIntInclusive( OVERCAST_MIN_TIME, OVERCAST_MAX_TIME );
160 phmnLength = Math.RandomIntInclusive( OVERCAST_MIN_TIME, OVERCAST_MAX_TIME );
161 }
162
163 if ( m_choosenWeather == BAD_WEATHER )
164 {
165 m_lastWeather = BAD_WEATHER;
166
167 phmnValue = Math.RandomFloatInclusive( 0.6, 1.0 );
168 phmnTime = Math.RandomIntInclusive( OVERCAST_MIN_TIME, OVERCAST_MAX_TIME );
169 phmnLength = Math.RandomIntInclusive( OVERCAST_MIN_TIME, OVERCAST_MAX_TIME );
170 }
171
172 m_Weather.GetOvercast().Set( phmnValue, phmnTime, phmnLength );
173
174 Debug.WeatherLog(string.Format("Chernarus::Weather::Overcast:: (%1) overcast: %2", g_Game.GetDayTime(), actual));
175 Debug.WeatherLog(string.Format("Chernarus::Weather::Overcast::Rain:: (%1) %2", g_Game.GetDayTime(), m_Weather.GetRain().GetActual()));
176
177 return true;
178
179 //-----------------------------------------------------------------------------------------------------------------------------
180 case EWeatherPhenomenon.RAIN:
181
182 float actualOvercast = m_Weather.GetOvercast().GetActual();
183
184 m_chance = Math.RandomIntInclusive( 0, 100 );
185 phmnValue = 0.2;
186 phmnTime = 90;
187 phmnLength = 30;
188
189 if ( actualOvercast <= RAIN_THRESHOLD )
190 {
191 m_Weather.GetRain().Set( 0.0, RAIN_TIME_MIN, RAIN_TIME_MAX );
192 Debug.WeatherLog(string.Format("Chernarus::Weather::Rain::ForceEnd:: (%1) %2 -> 0", g_Game.GetDayTime(), actual));
193 return true;
194 }
195
196 if ( actualOvercast > STORM_THRESHOLD )
197 {
198 phmnValue = Math.RandomFloatInclusive( 0.8, 1.0 );
199 phmnTime = Math.RandomInt( RAIN_TIME_MIN, RAIN_TIME_MAX );
200 phmnLength = 0;
201
202 m_Weather.GetRain().Set( phmnValue, phmnTime, phmnLength );
203 Debug.WeatherLog(string.Format("Chernarus::Weather::Rain::ForceStorm:: (%1) %2 -> %3", g_Game.GetDayTime(), actual, phmnValue));
204 return true;
205 }
206
207 //make a differnce in "normal rain"
208 if ( actualOvercast < 0.75 )
209 {
210 if ( m_chance < 30 )
211 {
212 phmnValue = Math.RandomFloatInclusive( 0.1, 0.3 );
213 phmnTime = Math.RandomInt( RAIN_TIME_MIN, RAIN_TIME_MAX );
214 phmnLength = 0;
215 }
216 else if ( m_chance < 60 )
217 {
218 phmnValue = Math.RandomFloatInclusive( 0.2, 0.5 );
219 phmnTime = Math.RandomInt( RAIN_TIME_MIN, RAIN_TIME_MAX );
220 phmnLength = 0;
221 }
222 else if ( m_chance < 80 )
223 {
224 phmnValue = Math.RandomFloatInclusive( 0.0, 0.2 );
225 phmnTime = Math.RandomInt( RAIN_TIME_MIN, RAIN_TIME_MAX );
226 phmnLength = 0;
227 }
228 else //also have the chance to not have rain at all
229 {
230 phmnValue = 0;
231 phmnTime = Math.RandomInt( RAIN_TIME_MIN, RAIN_TIME_MAX );
232 phmnLength = 120;
233 }
234 }
235 else
236 {
237 if ( m_chance < 25 )
238 {
239 phmnValue = Math.RandomFloatInclusive( 0.5, 0.7 );
240 phmnTime = Math.RandomInt( RAIN_TIME_MIN, RAIN_TIME_MAX );
241 phmnLength = 0;
242 }
243 else if ( m_chance < 50 )
244 {
245 phmnValue = Math.RandomFloatInclusive( 0.2, 0.4 );
246 phmnTime = Math.RandomInt( RAIN_TIME_MIN, RAIN_TIME_MAX );
247 phmnLength = 0;
248 }
249 else if ( m_chance < 75 )
250 {
251 phmnValue = Math.RandomFloatInclusive( 0.4, 0.6 );
252 phmnTime = Math.RandomInt( RAIN_TIME_MIN, RAIN_TIME_MAX );
253 phmnLength = 0;
254 }
255 else //also have the chance to not have rain at all
256 {
257 phmnValue = 0;
258 phmnTime = Math.RandomInt( RAIN_TIME_MIN, RAIN_TIME_MAX );
259 phmnLength = 120;
260 }
261 }
262
263 m_Weather.GetRain().Set( phmnValue, phmnTime, phmnLength );
264
265 Debug.WeatherLog(string.Format("Chernarus::Weather::Rain:: (%1) %2", g_Game.GetDayTime(), actual));
266
267 return true;
268
269 //-----------------------------------------------------------------------------------------------------------------------------
270 case EWeatherPhenomenon.FOG:
271
272 float fogMin = 0.0;
273 float fogMax = 0.15;
274 float fogTime = 1800.0;
275
276 float fogyMorning = Math.RandomFloatInclusive( 0.0, 1.0 );
277
278 if ( fogyMorning > 0.85 )
279 {
280 if ( (g_Game.GetDayTime() > 4 && g_Game.GetDayTime() < 7 ) )
281 {
282 fogMin = 0.10;
283 fogMax = 0.35;
284 fogTime = 300;
285 }
286 }
287
288 if ( m_Weather.GetOvercast().GetActual() < 0.3 )
289 {
290 fogMin = 0.0;
291 fogMax = 0.08;
292 fogTime = 900.0;
293 }
294
295 m_Weather.GetFog().Set( Math.RandomFloatInclusive( fogMin, fogMax ), fogTime, 0);
296
297 Debug.WeatherLog(string.Format("Chernarus::Weather::Fog:: (%1) %2", g_Game.GetDayTime(), actual));
298
299 return true;
300 }
301
302 return false;
303 }
EWeatherPhenomenon
EWeatherPhenomenon
Definition Weather.c:11
Debug
Definition Debug.c:14
Debug::WeatherLog
static void WeatherLog(string message=LOG_DEFAULT, string plugin=LOG_DEFAULT, string author=LOG_DEFAULT, string label=LOG_DEFAULT, string entity=LOG_DEFAULT)
Definition Debug.c:307
Weather::SetStorm
proto native void SetStorm(float density, float threshold, float timeOut)
Sets the thunderstorm properties.
Weather::SetWindFunctionParams
proto native void SetWindFunctionParams(float fnMin, float fnMax, float fnSpeed)
Sets function parameters that controls the wind behaviour (change in time).
Weather::SetWindMaximumSpeed
proto native void SetWindMaximumSpeed(float maxSpeed)
Sets the maximal wind speed in metre per second.
Weather::GetOvercast
proto native Overcast GetOvercast()
Returns an overcast phenomenon object.
Weather::SetRainThresholds
proto native void SetRainThresholds(float tMin, float tMax, float tTime)
Sets overcast threshold values for rain phenomena.
Weather::GetRain
proto native Rain GetRain()
Returns a rain phenomenon object.
Weather::GetFog
proto native Fog GetFog()
Returns a fog phenomenon object.
WorldData::m_sameWeatherCnt
int m_sameWeatherCnt
Definition ChernarusPlus.c:24
WorldData::BAD_WEATHER_CHANCE
const int BAD_WEATHER_CHANCE
Definition ChernarusPlus.c:18
WorldData::m_choosenWeather
int m_choosenWeather
Definition ChernarusPlus.c:28
WorldData::RAIN_TIME_MAX
const int RAIN_TIME_MAX
Definition ChernarusPlus.c:11
WorldData::STORM_THRESHOLD
const float STORM_THRESHOLD
Definition ChernarusPlus.c:5
WorldData::RAIN_THRESHOLD
const float RAIN_THRESHOLD
Definition ChernarusPlus.c:4
WorldData::m_lastWeather
int m_lastWeather
Definition ChernarusPlus.c:29
WorldData::RAIN_TIME_MIN
const int RAIN_TIME_MIN
Definition ChernarusPlus.c:10
WorldData::OVERCAST_MIN_TIME
const int OVERCAST_MIN_TIME
Definition ChernarusPlus.c:7
WorldData::CLEAR_WEATHER_CHANCE
const int CLEAR_WEATHER_CHANCE
Definition ChernarusPlus.c:17
WorldData::m_stepValue
int m_stepValue
Definition ChernarusPlus.c:25
WorldData::OVERCAST_MAX_TIME
const int OVERCAST_MAX_TIME
Definition ChernarusPlus.c:8
WorldData::m_clearWeatherChance
int m_clearWeatherChance
Definition ChernarusPlus.c:20
WorldData::BAD_WEATHER
const int BAD_WEATHER
Definition ChernarusPlus.c:15
WorldData::m_badWeatherChance
int m_badWeatherChance
Definition ChernarusPlus.c:22
WorldData::CLOUDY_WEATHER
const int CLOUDY_WEATHER
Definition ChernarusPlus.c:14
WorldData::m_chance
int m_chance
Definition ChernarusPlus.c:26
WorldData::CLEAR_WEATHER
const int CLEAR_WEATHER
Definition ChernarusPlus.c:13
Math::RandomInt
static proto int RandomInt(int min, int max)
Returns a random int number between and min [inclusive] and max [exclusive].
Math::RandomFloatInclusive
static float RandomFloatInclusive(float min, float max)
Returns a random float number between and min [inclusive] and max [inclusive].
Definition EnMath.c:106
Math::RandomIntInclusive
static int RandomIntInclusive(int min, int max)
Returns a random int number between and min [inclusive] and max [inclusive].
Definition EnMath.c:54

Перекрестные ссылки g_Game, Math::RandomFloatInclusive(), Math::RandomInt(), Math::RandomIntInclusive() и Debug::WeatherLog().

◆ WeatherOnBeforeChange() [3/3]

override bool WeatherOnBeforeChange ( EWeatherPhenomenon type,
float actual,
float change,
float time )
inlineprotected
76 {
77 int phmnTime = 5;
78 int phmnLength = 10;
79 float phmnValue = 0;
80
81 m_Weather.SetStorm( 1.0, STORM_THRESHOLD, 20 );
82
83 m_Weather.SetRainThresholds( 0.0, 1.0, 60 );
84 m_Weather.SetWindMaximumSpeed( 20 );
85 m_Weather.SetWindFunctionParams( 0.1, 1.0, 20 );
86
87 switch (type)
88 {
89 //-----------------------------------------------------------------------------------------------------------------------------
90 case EWeatherPhenomenon.OVERCAST:
91
92 //went something goes wrong choose some default random weather
93 phmnValue = Math.RandomFloatInclusive( 0.1, 0.4 );
94 phmnTime = Math.RandomIntInclusive( OVERCAST_MIN_TIME, OVERCAST_MAX_TIME );
95 phmnLength = Math.RandomIntInclusive( OVERCAST_MIN_TIME, OVERCAST_MAX_TIME );
96
97 //----
98 //calculate next weather
99 m_chance = Math.RandomIntInclusive( 0, 100 );
100
101 //--
102 if ( m_lastWeather == CLEAR_WEATHER )
103 {
104 m_clearWeatherChance -= ( m_stepValue * m_sameWeatherCnt); //decrease the chance of the same weather
105 }
106
107 if ( m_lastWeather == CLOUDY_WEATHER )
108 {
109 m_clearWeatherChance += ( m_stepValue * m_sameWeatherCnt); //increase the chance of the better weather
110 m_badWeatherChance -= ( m_stepValue * m_sameWeatherCnt);
111 }
112
113 if ( m_lastWeather == BAD_WEATHER )
114 {
115 m_clearWeatherChance += m_stepValue; //increase the chance of the better weather slightly
116 m_badWeatherChance += ( m_stepValue * m_sameWeatherCnt ); //decrease the chance of the same weather
117 }
118
119 //----
120 if ( m_chance < m_clearWeatherChance )
121 {
122 m_choosenWeather = CLEAR_WEATHER;
123 if ( m_lastWeather == CLEAR_WEATHER )
124 m_sameWeatherCnt ++;
125 }
126 else if ( m_chance > m_badWeatherChance )
127 {
128 m_choosenWeather = BAD_WEATHER;
129 if ( m_lastWeather == BAD_WEATHER )
130 m_sameWeatherCnt ++;
131 }
132 else
133 {
134 m_choosenWeather = CLOUDY_WEATHER;
135 if ( m_lastWeather == CLOUDY_WEATHER )
136 m_sameWeatherCnt ++;
137 }
138
139 if ( m_choosenWeather != m_lastWeather )
140 m_sameWeatherCnt = 0;
141
142 m_clearWeatherChance = CLEAR_WEATHER_CHANCE;
143 m_badWeatherChance = BAD_WEATHER_CHANCE;
144
145 //----
146 //set choosen weather
147 if ( m_choosenWeather == CLEAR_WEATHER )
148 {
149 m_lastWeather = CLEAR_WEATHER;
150
151 phmnValue = Math.RandomFloatInclusive( 0.0, 0.3 );
152 phmnTime = Math.RandomIntInclusive( OVERCAST_MIN_TIME, OVERCAST_MAX_TIME );
153 phmnLength = Math.RandomIntInclusive( OVERCAST_MIN_TIME, OVERCAST_MAX_TIME );
154 }
155
156 if ( m_choosenWeather == CLOUDY_WEATHER )
157 {
158 m_lastWeather = CLOUDY_WEATHER;
159
160 phmnValue = Math.RandomFloatInclusive( 0.3, 0.7 );
161 phmnTime = Math.RandomIntInclusive( OVERCAST_MIN_TIME, OVERCAST_MAX_TIME );
162 phmnLength = Math.RandomIntInclusive( 0, OVERCAST_MIN_TIME );
163 }
164
165 if ( m_choosenWeather == BAD_WEATHER )
166 {
167 m_lastWeather = BAD_WEATHER;
168
169 phmnValue = Math.RandomFloatInclusive( 0.7, 1.0 );
170 phmnTime = Math.RandomIntInclusive( OVERCAST_MIN_TIME, OVERCAST_MAX_TIME );
171 phmnLength = Math.RandomIntInclusive( 0, OVERCAST_MIN_TIME );
172 }
173
174 m_Weather.GetOvercast().Set( phmnValue, phmnTime, phmnLength );
175
176 Debug.WeatherLog(string.Format("Enoch::Weather::Overcast:: (%1) overcast: %2", g_Game.GetDayTime(), actual));
177 Debug.WeatherLog(string.Format("Enoch::Weather::Overcast::Rain:: (%1) %2", g_Game.GetDayTime(), m_Weather.GetRain().GetActual()));
178
179 return true;
180
181 //-----------------------------------------------------------------------------------------------------------------------------
182 case EWeatherPhenomenon.RAIN:
183 float actualOvercast = m_Weather.GetOvercast().GetActual();
184
185 m_chance = Math.RandomIntInclusive( 0, 100 );
186 phmnValue = 0.2;
187 phmnTime = 90;
188 phmnLength = 30;
189
190 if ( actualOvercast <= RAIN_THRESHOLD )
191 {
192 m_Weather.GetRain().Set( 0.0, RAIN_TIME_MIN, RAIN_TIME_MAX );
193 Debug.WeatherLog (string.Format("Enoch::Weather::Rain::ForceEnd:: (%1) %2 -> 0", g_Game.GetDayTime(), actual));
194 return true;
195 }
196
197 if ( actualOvercast > STORM_THRESHOLD )
198 {
199 phmnValue = Math.RandomFloatInclusive( 0.8, 1.0 );
200 phmnTime = Math.RandomInt( RAIN_TIME_MIN, RAIN_TIME_MAX );
201 phmnLength = 0;
202
203 m_Weather.GetRain().Set( phmnValue, phmnTime, phmnLength );
204 Debug.WeatherLog(string.Format("Enoch::Weather::Rain::ForceStorm:: (%1) %2 -> %3", g_Game.GetDayTime(), actual, phmnValue));
205 return true;
206 }
207
208 //make a differnce in "normal rain"
209 if ( actualOvercast < 0.75 )
210 {
211 if ( m_chance < 30 )
212 {
213 phmnValue = Math.RandomFloatInclusive( 0.1, 0.3 );
214 phmnTime = Math.RandomInt( RAIN_TIME_MIN, RAIN_TIME_MAX );
215 phmnLength = 0;
216 }
217 else if ( m_chance < 60 )
218 {
219 phmnValue = Math.RandomFloatInclusive( 0.2, 0.4 );
220 phmnTime = Math.RandomInt( RAIN_TIME_MIN, RAIN_TIME_MAX );
221 phmnLength = 0;
222 }
223 else if ( m_chance < 85 )
224 {
225 phmnValue = Math.RandomFloatInclusive( 0.0, 0.2 );
226 phmnTime = Math.RandomInt( RAIN_TIME_MIN, RAIN_TIME_MAX );
227 phmnLength = 0;
228 }
229 else //also have the chance to not have rain at all
230 {
231 phmnValue = 0;
232 phmnTime = Math.RandomInt( RAIN_TIME_MIN, RAIN_TIME_MAX );
233 phmnLength = 120;
234 }
235 }
236 else if ( actualOvercast < STORM_THRESHOLD )
237 {
238 if ( m_chance < 15 )
239 {
240 phmnValue = Math.RandomFloatInclusive( 0.4, 0.6 );
241 phmnTime = Math.RandomInt( RAIN_TIME_MIN, RAIN_TIME_MAX );
242 phmnLength = 0;
243 }
244 else if ( m_chance < 50 )
245 {
246 phmnValue = Math.RandomFloatInclusive( 0.2, 0.4 );
247 phmnTime = Math.RandomInt( RAIN_TIME_MIN, RAIN_TIME_MAX );
248 phmnLength = 0;
249 }
250 else if ( m_chance < 90 )
251 {
252 phmnValue = Math.RandomFloatInclusive( 0.6, 0.8 );
253 phmnTime = Math.RandomInt( RAIN_TIME_MIN, RAIN_TIME_MAX );
254 phmnLength = 0;
255 }
256 else //also have the chance to not have rain at all
257 {
258 phmnValue = 0;
259 phmnTime = Math.RandomInt( RAIN_TIME_MIN, RAIN_TIME_MAX );
260 phmnLength = 120;
261 }
262 }
263 else
264 {
265 if ( m_chance < 50 )
266 {
267 phmnValue = Math.RandomFloatInclusive( 0.9, 1.0 );
268 phmnTime = Math.RandomInt( RAIN_TIME_MIN, RAIN_TIME_MAX );
269 phmnLength = 0;
270 }
271 else
272 {
273 phmnValue = Math.RandomFloatInclusive( 0.8, 0.9 );
274 phmnTime = Math.RandomInt( RAIN_TIME_MIN, RAIN_TIME_MAX );
275 phmnLength = 0;
276 }
277 }
278
279 m_Weather.GetRain().Set( phmnValue, phmnTime, phmnLength );
280
281 Debug.WeatherLog(string.Format("Enoch::Weather::Rain:: (%1) %2", g_Game.GetDayTime(), actual));
282 return true;
283
284 //-----------------------------------------------------------------------------------------------------------------------------
285 case EWeatherPhenomenon.FOG:
286 int year, month, day, hour, minute;
287 GetGame().GetWorld().GetDate(year, month, day, hour, minute);
288 if (( hour >= 1 ) && ( hour <= 5 ))
289 {
290 m_Weather.GetFog().Set( 0.1, 1800, 0 );
291 } else {
292 m_Weather.GetFog().Set( 0.0, 1800, 0 );
293 }
294
295 Debug.WeatherLog(string.Format("Enoch::Weather::Fog:: (%1) %2", g_Game.GetDayTime(), actual));
296
297 return true;
298 }
299 return false;
300 }

Перекрестные ссылки g_Game, GetGame(), Math::RandomFloatInclusive(), Math::RandomInt(), Math::RandomIntInclusive() и Debug::WeatherLog().

Поля

◆ BAD_WEATHER

const int BAD_WEATHER = 3
private

◆ BAD_WEATHER_CHANCE

const int BAD_WEATHER_CHANCE = 80
private

◆ CHERNARUS_ARTY_STRIKE_POS

const ref array<vector> CHERNARUS_ARTY_STRIKE_POS
staticprotected
Инициализатор
=
{
"-500.00 165.00 5231.69",
"-500.00 300.00 9934.41",
"10406.86 192.00 15860.00",
"4811.75 370.00 15860.00",
"-500.00 453.00 15860.00"
}
33 {
34 "-500.00 165.00 5231.69",
35 "-500.00 300.00 9934.41",
36 "10406.86 192.00 15860.00",
37 "4811.75 370.00 15860.00",
38 "-500.00 453.00 15860.00"
39 };

◆ CLEAR_WEATHER

const int CLEAR_WEATHER = 1
private

◆ CLEAR_WEATHER_CHANCE

const int CLEAR_WEATHER_CHANCE = 30
private

◆ CLOUDY_WEATHER

const int CLOUDY_WEATHER = 2
private

◆ LIVONIA_ARTY_STRIKE_POS

const ref array<vector> LIVONIA_ARTY_STRIKE_POS
staticprotected
Инициализатор
=
{
"7440.00 417.00 -500.00",
"-500.00 276.00 5473.00",
"-500.00 265.00 9852.00",
"4953.00 240.00 13300.00",
"9620.00 188.00 13300.00",
"13300.00 204.00 10322.00",
"13300.00 288.00 6204.00",
"13300.00 296.00 -500.00"
}
32 {
33 "7440.00 417.00 -500.00",
34 "-500.00 276.00 5473.00",
35 "-500.00 265.00 9852.00",
36 "4953.00 240.00 13300.00",
37 "9620.00 188.00 13300.00",
38 "13300.00 204.00 10322.00",
39 "13300.00 288.00 6204.00",
40 "13300.00 296.00 -500.00"
41 };

◆ m_badWeatherChance

int m_badWeatherChance = BAD_WEATHER_CHANCE
protected

◆ m_chance

int m_chance = 50
protected

◆ m_choosenWeather

int m_choosenWeather = 1
protected

◆ m_clearWeatherChance

int m_clearWeatherChance = CLEAR_WEATHER_CHANCE
protected

◆ m_DayTemperature

float m_DayTemperature
protected

Используется в GetDayTemperature() и Init().

◆ m_EnvironmentTemperature

float m_EnvironmentTemperature
protected

Используется в GetBaseEnvTemperature(), Init() и UpdateBaseEnvTemperature().

◆ m_FiringPos

ref array<vector> m_FiringPos
protected

Используется в GetArtyFiringPos().

◆ m_lastWeather

int m_lastWeather = 0
protected

◆ m_MaxTemps

float m_MaxTemps[12]
protected

Используется в CalcBaseEnvironmentTemperature() и Init().

◆ m_MinTemps

float m_MinTemps[12]
protected

Используется в CalcBaseEnvironmentTemperature() и Init().

◆ m_NightTemperature

float m_NightTemperature
protected

Используется в GetNightTemperature() и Init().

◆ m_sameWeatherCnt

int m_sameWeatherCnt = 0
protected

◆ m_stepValue

int m_stepValue = 5
protected

◆ m_Sunrise_Jan

float m_Sunrise_Jan
protected

Используется в GetApproxSunriseTime() и Init().

◆ m_Sunrise_Jul

float m_Sunrise_Jul
protected

Используется в GetApproxSunriseTime() и Init().

◆ m_Sunset_Jan

float m_Sunset_Jan
protected

Используется в GetApproxSunsetTime() и Init().

◆ m_Sunset_Jul

float m_Sunset_Jul
protected

Используется в GetApproxSunsetTime() и Init().

◆ m_Timer

float m_Timer
protected

Используется в Init() и UpdateBaseEnvTemperature().

◆ m_Weather

Weather m_Weather
protected

Используется в Init().

◆ OVERCAST_MAX_TIME

const int OVERCAST_MAX_TIME = 900
private

◆ OVERCAST_MIN_TIME

const int OVERCAST_MIN_TIME = 600
private

◆ RAIN_THRESHOLD

const float RAIN_THRESHOLD = 0.6
private

◆ RAIN_TIME_MAX

const int RAIN_TIME_MAX = 120
private

◆ RAIN_TIME_MIN

const int RAIN_TIME_MIN = 60
private

◆ STORM_THRESHOLD

const float STORM_THRESHOLD = 0.9
private
Объявления и описания членов классов находятся в файлах: