Система погодных эффектов и тумана

Добавлен , опубликован
Алгоритмы, Наработки и Способности
Способ реализации:
cJass
Тип:
Наработка
Версия Warcraft:
1.26

Система погоды

Настраиваемые параметры библиотеки
		private map = bj_mapInitialPlayableArea
        private LIGHTNING_MODEL = "Lightnings Long.mdx"
        private MAX_PLAYERS = 12
        // чем больше ключ, тем реже событие
        private LIGHTNING_KEY = 50
        //===================
        private LIGHTWIND_MIN_TIME = 15.  // минимум секунд длительности ветренной погоды
        private LIGHTWIND_MAX_TIME = 55.  // максимум секунд длительности ветренной погоды
        private LIGHTWIND_KEY = 75
        
        private HEAVYWIND_MIN_TIME = 15.  // минимум секунд длительности ветренной погоды
        private HEAVYWIND_MAX_TIME = 45.  // максимум секунд длительности ветренной погоды
        private HEAVYWIND_KEY = 95
        
        private LIGHTRAIN_MIN_TIME = 15.  // минимум секунд длительности дождя
        private LIGHTRAIN_MAX_TIME = 85.  // максимум секунд длительности дождя
        private LIGHTRAIN_KEY = 65
        private LIGHTRAIN_VOLUME = 40
        
        private RAIN_MIN_TIME = 15.  // минимум секунд длительности дождя
        private RAIN_MAX_TIME = 85.  // максимум секунд длительности дождя
        private RAIN_KEY = 45
        private RAIN_VOLUME = 65
        
        private MOON_MIN_TIME = 12.   // минимум секунд длительности солнечной погоды
        private MOON_MAX_TIME = 27.   // максимум секунд длительности  погоды
        private MOON_KEY = 45
        
        private SUN_MIN_TIME = 15.   // минимум секунд длительности солнечной погоды
        private SUN_MAX_TIME = 55.   // максимум секунд длительности солнечной погоды
        private SUN_KEY = 45
        //===================
        private BLIZZARD_MIN_TIME = 15. // минимум секунд длительности снежной бури
        private BLIZZARD_MAX_TIME = 65. // максимум секунд длительности снежной бури
        private BLIZZARD_KEY = 45
        
        private HEAVYSNOW_MIN_TIME = 15. // минимум секунд длительности сильного снегопада
        private HEAVYSNOW_MAX_TIME = 75. // максимум секунд длительности сильного снегопада
        private HEAVYSNOW_KEY = 45
        
        private LIGHTSNOW_MIN_TIME = 15. // минимум секунд длительности слабого снегопада
        private LIGHTSNOW_MAX_TIME = 95. // максимум секунд длительности слабого снегопада
        private LIGHTSNOW_KEY = 45
        //===================
        private GENERATOR_BLOCK_VALUE = 1536.
        private WEATHER_CREATION_TICK = 0.05
код
library Weather initializer Init

#include "cj_types.j"
//globals
    // настраиваемые параматры
    public int SEASON = SUMMER
    private bool Showed[MAX_PLAYERS]
    private timer WeatherTimer = CreateTimer()
    private real Weather_Time = 0.
    private force Players = CreateForce()
    private group tempGr = CreateGroup()
    
    private timer Timer = null
    private rect GameRect[1000]
    private weathereffect WeatherOnRect[1000]
    private int RectIndex = 0
    private int WeatherIndex = 0
    private int WeatherId = -2
    private int WeatherTypeId[8]
    private sound RainSound
    int CurrentWeather = -1
    
    
    enum (weather_seasons) { wsns, SUMMER, WINTER, DESERT }
    enum (weather_types) { SUNLIGHT, MOONLIGHT, LIGHTWIND, HEAVYWIND, LIGHTRAIN, HEAVYRAIN, LIGHTSNOW, HEAVYSNOW, BLIZZARD }
    
    
    
    define {
        private map = bj_mapInitialPlayableArea
        private LIGHTNING_MODEL = "Lightnings Long.mdx"
        private MAX_PLAYERS = 12
        // чем больше ключ, тем реже событие
        private LIGHTNING_KEY = 50
        //===================
        private LIGHTWIND_MIN_TIME = 15.  // минимум секунд длительности ветренной погоды
        private LIGHTWIND_MAX_TIME = 55.  // максимум секунд длительности ветренной погоды
        private LIGHTWIND_KEY = 75
        
        private HEAVYWIND_MIN_TIME = 15.  // минимум секунд длительности ветренной погоды
        private HEAVYWIND_MAX_TIME = 45.  // максимум секунд длительности ветренной погоды
        private HEAVYWIND_KEY = 95
        
        private LIGHTRAIN_MIN_TIME = 15.  // минимум секунд длительности дождя
        private LIGHTRAIN_MAX_TIME = 85.  // максимум секунд длительности дождя
        private LIGHTRAIN_KEY = 65
        private LIGHTRAIN_VOLUME = 40
        
        private RAIN_MIN_TIME = 15.  // минимум секунд длительности дождя
        private RAIN_MAX_TIME = 85.  // максимум секунд длительности дождя
        private RAIN_KEY = 45
        private RAIN_VOLUME = 65
        
        private MOON_MIN_TIME = 12.   // минимум секунд длительности солнечной погоды
        private MOON_MAX_TIME = 27.   // максимум секунд длительности  погоды
        private MOON_KEY = 45
        
        private SUN_MIN_TIME = 15.   // минимум секунд длительности солнечной погоды
        private SUN_MAX_TIME = 55.   // максимум секунд длительности солнечной погоды
        private SUN_KEY = 45
        //===================
        private BLIZZARD_MIN_TIME = 15. // минимум секунд длительности снежной бури
        private BLIZZARD_MAX_TIME = 65. // максимум секунд длительности снежной бури
        private BLIZZARD_KEY = 45
        
        private HEAVYSNOW_MIN_TIME = 15. // минимум секунд длительности сильного снегопада
        private HEAVYSNOW_MAX_TIME = 75. // максимум секунд длительности сильного снегопада
        private HEAVYSNOW_KEY = 45
        
        private LIGHTSNOW_MIN_TIME = 15. // минимум секунд длительности слабого снегопада
        private LIGHTSNOW_MAX_TIME = 95. // максимум секунд длительности слабого снегопада
        private LIGHTSNOW_KEY = 45
        //===================
        private GENERATOR_BLOCK_VALUE = 1536.
        private WEATHER_CREATION_TICK = 0.05
    }

    
    private void PreloadSound(string s) { //подгрузка звука 3D
        sound snd = CreateSound(s,false,true,true,10,10,"CombatSoundsEAX")
            SetSoundChannel(snd,5)
            SetSoundVolume(snd,127)
            SetSoundPitch(snd, 1)
            SetSoundDistances(snd,999999,99999)
            SetSoundDistanceCutoff(snd,99999)
            SetSoundConeAngles(snd,0.0,0.0,127)
            SetSoundConeOrientation(snd,0.0,0.0,0.0)
            SetSoundPosition(snd,0.0,0.0,50.0)
            StartSound(snd)
            StopSound(snd, false, false)
        snd = null
    }

    private void AddSound(string s, real x, real y) {
        sound snd = CreateSound(s, false, true, true, 10, 10, "CombatSoundsEAX")
            SetSoundChannel(snd, GetRandomInt(25, 45))
            SetSoundVolume(snd, 127)
            SetSoundPitch(snd, 1)
            SetSoundDistances(snd, 600, 10000)
            SetSoundDistanceCutoff(snd, 2100)
            SetSoundConeAngles(snd, 0.0, 0.0, 127)
            SetSoundConeOrientation(snd, 0.0, 0.0, 0.0)
            SetSoundPosition(snd, x, y, 50.)
            StartSound(snd)
            KillSoundWhenDone(snd)
        snd = null
    }
    

    private bool GetPlayersInRange_filter(){
        if Showed[GetPlayerId(GetOwningPlayer(GetFilterUnit()))] { ForceAddPlayer(Players, GetOwningPlayer(GetFilterUnit())) }
    return false
    }

    private void GetPlayersInRange (real x, real y, real range) {
        ForceClear(Players)
        GroupEnumUnitsInRange(tempGr, x, y, range, Filter(function GetPlayersInRange_filter))
    }
        
    private function LightningFilter takes real duration, int alpha returns nothing
        int c = -1

           if bj_cineFadeContinueTimer != null then
                call DestroyTimer(bj_cineFadeContinueTimer)
            endif
            if bj_cineFadeFinishTimer != null then
                call DestroyTimer(bj_cineFadeFinishTimer)
            endif
            
            call SetCineFilterTexture("ReplaceableTextures\\CameraMasks\\White_mask.blp")
            call SetCineFilterBlendMode(BLEND_MODE_BLEND)
            call SetCineFilterTexMapFlags(TEXMAP_FLAG_NONE)
            call SetCineFilterStartUV(0, 0, 1, 1)
            call SetCineFilterEndUV(0, 0, 1, 1)
            call SetCineFilterStartColor(255, 255, 255, alpha)
            call SetCineFilterEndColor(255, 255, 255, 0)
            call SetCineFilterDuration(duration)
            
            while (c++ < MAX_PLAYERS) {
                if GetLocalPlayer() == Player(c) {
                    DisplayCineFilter(IsPlayerInForce(Player(c), Players))
                }
            }
            
    endfunction

    
    public void ToggleForPlayer(int p, bool b){
        int i = 0
            Showed[p] = b
            while(i++ < WeatherIndex) {
                if GetLocalPlayer() == Player(p){
                    EnableWeatherEffect(WeatherOnRect[i], b)
                        if b {
                            if CurrentWeather == LIGHTRAIN { StartSound(RainSound); SetSoundVolume(RainSound, LIGHTRAIN_VOLUME) }
                            elseif CurrentWeather == HEAVYRAIN { StartSound(RainSound); SetSoundVolume(RainSound, RAIN_VOLUME) }
                        }
                        else {
                            StopSound(RainSound, false, true)
                        }
                }
            }
    }
    
    private void StartLocalSound(int volume){
        int c = -1
            while(c++ < MAX_PLAYERS){
                if GetLocalPlayer() == Player(c){
                    if Showed[c] { StartSound(RainSound); SetSoundVolume(RainSound, volume) }
                    else { StopSound(RainSound, false, false) }
                }
            }
    }
    
    private void Visibility(weathereffect w){
        int c = -1
            while(c++ < MAX_PLAYERS){
                if GetLocalPlayer() == Player(c){
                    EnableWeatherEffect(w, Showed[c])
                }
            }
    }
    
    
     private void CreateWeatherOnRects(){
        WeatherIndex++
            if WeatherOnRect[WeatherIndex] != null {
                RemoveWeatherEffect(WeatherOnRect[WeatherIndex])
            }
            
        WeatherOnRect[WeatherIndex] = AddWeatherEffect(GameRect[WeatherIndex], WeatherId)
        EnableWeatherEffect(WeatherOnRect[WeatherIndex], true)
        Visibility(WeatherOnRect[WeatherIndex])
            
            if WeatherIndex == RectIndex { 
                DestroyTimer(Timer)
                Timer = null
            }
    }
    
    
    private void DestroyWeatherOnRects(){
        EnableWeatherEffect(WeatherOnRect[WeatherIndex], false)
        RemoveWeatherEffect(WeatherOnRect[WeatherIndex])
        WeatherOnRect[WeatherIndex] = null
        WeatherIndex--
        
            if WeatherIndex == 0 { 
                DestroyTimer(Timer)
                Timer = null
                WeatherId = -1
                CurrentWeather = -1
            }
    }
    
    
    void StopWeather(){
        if Timer != null { DestroyTimer(Timer) }
        StopSound(RainSound, false, true)
        Timer = CreateTimer()
        TimerStart(Timer, WEATHER_CREATION_TICK, true, function DestroyWeatherOnRects)
    }

    
    function RainUpdate takes nothing returns nothing
        local integer r
        real x, y
        
            Weather_Time -= 0.05
            
            if Weather_Time <= 0. then
                DestroyTimer(GetExpiredTimer())
                StopWeather()
            else
                r = GetRandomInt(1, LIGHTNING_KEY)
                    if r <= 3 {
                        x = GetRandomReal(GetRectMinX(map) ,GetRectMaxX(map))
                        y = GetRandomReal(GetRectMinY(map), GetRectMaxY(map))
                            if r == 1 then
                                GetPlayersInRange(x, y, 1900.)
                                LightningFilter(0.5, 170)
                                AddSound("Thunder Low.wav", x,y)
                            elseif r == 2 then
                                GetPlayersInRange(x, y, 1900.)
                                LightningFilter(0.75, 205)
                                AddSound("Thunder Normal.wav", x,y)
                            elseif r == 3 then
                                debug call msg("high thunder")
                                GetPlayersInRange(x, y, 1900.)
                                LightningFilter(1., 235)
                                bj_lastCreatedEffect = AddSpecialEffect(LIGHTNING_MODEL, x, y)
                                DestroyEffect(bj_lastCreatedEffect)
                                AddSound("Thunder High.wav", x, y)
                            endif
                    }
            endif
            
    endfunction

    
    void StartWeather(int weather){
        WeatherId = WeatherTypeId[weather]
        CurrentWeather = weather
            if weather == SUNLIGHT {
                TimerStart(WeatherTimer, GetRandomReal(SUN_MIN_TIME + 3., SUN_MAX_TIME), false, function StopWeather)
            }
            elseif weather == MOONLIGHT {
                TimerStart(WeatherTimer, GetRandomReal(MOON_MIN_TIME + 3., MOON_MAX_TIME), false, function StopWeather)
            }
            elseif weather == LIGHTRAIN {
                TimerStart(WeatherTimer, GetRandomReal(LIGHTRAIN_MIN_TIME + 3., LIGHTRAIN_MAX_TIME), false, function StopWeather)
                StartLocalSound(LIGHTRAIN_VOLUME)
            }
            elseif weather == HEAVYRAIN {
                TimerStart(CreateTimer(), 0.05, true, function RainUpdate)
                Weather_Time = GetRandomReal(RAIN_MIN_TIME + 3., RAIN_MAX_TIME)
                StartLocalSound(RAIN_VOLUME)
            }
            elseif weather == LIGHTWIND {
                TimerStart(WeatherTimer, GetRandomReal(LIGHTWIND_MIN_TIME + 3., LIGHTWIND_MAX_TIME), false, function StopWeather)
            }
            elseif weather == HEAVYWIND {
                TimerStart(WeatherTimer, GetRandomReal(HEAVYWIND_MIN_TIME + 3., HEAVYWIND_MAX_TIME), false, function StopWeather)
            }
            elseif weather == LIGHTSNOW {
                TimerStart(WeatherTimer, GetRandomReal(LIGHTSNOW_MIN_TIME + 3., LIGHTSNOW_MAX_TIME), false, function StopWeather)
            }
            elseif weather == HEAVYSNOW {
                TimerStart(WeatherTimer, GetRandomReal(HEAVYSNOW_MIN_TIME + 3., HEAVYSNOW_MAX_TIME), false, function StopWeather)
            }
            elseif weather == BLIZZARD {
                TimerStart(WeatherTimer, GetRandomReal(BLIZZARD_MIN_TIME + 3., BLIZZARD_MAX_TIME), false, function StopWeather)
            }
            
        WeatherIndex = 0
        if Timer != null { DestroyTimer(Timer) }
        Timer = CreateTimer()
        TimerStart(Timer, WEATHER_CREATION_TICK, true, function CreateWeatherOnRects)
    }


    private void WeatherUpdate() {
        real dt = GetFloatGameState(GAME_STATE_TIME_OF_DAY)
        
            if CurrentWeather == SUNLIGHT {
                if (dt < 9. or dt > 18.) { StopWeather() }
            }
            elseif CurrentWeather == MOONLIGHT {
                if (dt < 21. and dt > 4.) { StopWeather() }
            }
                
            if WeatherId == -1 {
                if ((dt >= 9. and dt < 18.) and GetRandomInt(1, SUN_KEY) == 1) {
                    StartWeather(SUNLIGHT)
                }
                elseif ((dt > 21. or dt < 4.) and GetRandomInt(1, MOON_KEY) == 1) {
                    StartWeather(MOONLIGHT)
                }
                else {
                    if SEASON == SUMMER {
                        // слабый ветер
                        if GetRandomInt(1, LIGHTWIND_KEY) == 1 {
                            StartWeather(LIGHTWIND)
                        }
                        // сильный ветер
                        elseif GetRandomInt(1, HEAVYWIND_KEY) == 1 {
                            StartWeather(HEAVYWIND)
                        }
                        // легкий дождь
                        elseif GetRandomInt(1, LIGHTRAIN_KEY) == 1 {
                            StartWeather(LIGHTRAIN)
                        }
                        // сильный дождь
                        elseif GetRandomInt(1, RAIN_KEY) == 1 {
                            StartWeather(HEAVYRAIN)
                        }
                    }
                    elseif SEASON == WINTER {
                        // легкий снегопад
                        if GetRandomInt(1, LIGHTSNOW_KEY) == 1 {
                            StartWeather(LIGHTSNOW)
                        }
                        // сильный снегопад
                        elseif GetRandomInt(1, HEAVYSNOW_KEY) == 1 {
                            StartWeather(HEAVYSNOW)
                        }
                        // метель
                        elseif GetRandomInt(1, BLIZZARD_KEY) == 1 {
                            StartWeather(BLIZZARD)
                        }
                    }
                }
            }
    }
    
   // генератор ректов
//========================
// GLOBALS
    int X_BLOCKS
    int Y_BLOCKS
    int TOTAL_Y_BLOCKS
//========================
    
    private void RectsInit(){
        real start_x = GetRectMinX(map)
        real start_y = GetRectMaxY(map)
        int x = 0
        real max_rect_x
        real max_rect_y
        real min_rect_y
        
            while(x++ < X_BLOCKS) {

                max_rect_x = start_x + (GENERATOR_BLOCK_VALUE * x)
                max_rect_y = start_y - (GENERATOR_BLOCK_VALUE * (TOTAL_Y_BLOCKS - Y_BLOCKS))
                min_rect_y = max_rect_y - GENERATOR_BLOCK_VALUE
                
                if max_rect_x > GetRectMaxX(map) { max_rect_x = GetRectMaxX(map) }
                if min_rect_y < GetRectMinY(map) { min_rect_y = GetRectMinY(map) }
                
                
                if (max_rect_x <= max_rect_x - GENERATOR_BLOCK_VALUE or min_rect_y >= max_rect_y){ }
                else {
                    RectIndex++
                    GameRect[RectIndex] = Rect(max_rect_x - GENERATOR_BLOCK_VALUE, min_rect_y, max_rect_x, max_rect_y)
                }
            }
            PreloadSound("Thunder High.wav") 
            PreloadSound("Thunder Normal.wav.wav") 
            PreloadSound("Thunder Low.wav") 
            Y_BLOCKS--
            if Y_BLOCKS <= 0 { 
                DestroyTimer(GetExpiredTimer())
                WeatherId = -1
            }
    }

    
    
    private function Init takes nothing returns nothing
        int c = -1
            while(c++ < MAX_PLAYERS) { Showed[c] = true }
            X_BLOCKS = R2I((GetRectMaxX(map) - GetRectMinX(map)) / GENERATOR_BLOCK_VALUE) + 1
            Y_BLOCKS = R2I((GetRectMaxY(map) - GetRectMinY(map)) / GENERATOR_BLOCK_VALUE) + 1
            TOTAL_Y_BLOCKS = Y_BLOCKS
            TimerStart(CreateTimer(), 0.05, true, function RectsInit)
            RainSound = CreateSound("rain.wav", true, false, false, 100, 100, "")
            
            WeatherTypeId[SUNLIGHT] = 'LRaa'
            WeatherTypeId[MOONLIGHT] = 'LRma'
            WeatherTypeId[LIGHTWIND] = 'WOlw'
            WeatherTypeId[HEAVYWIND] = 'WOcw'
            WeatherTypeId[LIGHTRAIN] = 'RAlr'
            WeatherTypeId[HEAVYRAIN] = 'RLhr'
            WeatherTypeId[LIGHTSNOW] = 'SNls'
            WeatherTypeId[HEAVYSNOW] = 'SNhs'
            WeatherTypeId[BLIZZARD] = 'SNbs'
            TimerStart(CreateTimer(), 1., true, function WeatherUpdate)
    endfunction

endlibrary

Наработка пассивно в течении времени генерирует один из случайных погодных эффектов, таких как
  • Солнечные лучи
  • Лунные лучи
  • Слабый ветер
  • Сильный ветер
  • Легкий дождь
  • Сильный дождь
Можно самому запускать погодный эффект функцией
void StartWeather(int weather)
Принимаемые аргументы
SUNLIGHT, MOONLIGHT, LIGHTWIND, HEAVYWIND, LIGHTRAIN, HEAVYRAIN, LIGHTSNOW, HEAVYSNOW, BLIZZARD
StartWeather(HEAVYWIND)
Можно так же сменить сезон погоды, установив публичной переменной SEASON значение WINTER, и обратно на летнюю использовав SUMMER
Weather_SEASON  = WINTER
Сменившись, система будет подбирать один из снегопадов.

Убрать погодный эффект с карты можно с помощью функции
StopWeather()

Можно скрыть погодные эффекты для какого либо игрока, воспользовавшись функцией
public void ToggleForPlayer(int p, bool b)
p = номер игрока
b = true показать, false скрыть
Кат
Weather_ToggleForPlayer(0, false)

При сильном дожде происходят вспышки молнии, и можно увидеть как она ударяет в землю. Так же слышен гром.

Используемый импорт
  • звук Thunder Low.wav
  • звук Thunder Normal.wav
  • звук Thunder High.wav
  • звук rain.wav
  • эффект "Lightnings Long.mdx"

UPD
Добавлен звук дождя, заменена модель молнии, пара фиксов

Система тумана

Настройки библиотеки
	private constant real DELTA_TIME = (480. / HOURS_IN_DAY)

	private START_TIME = 12.
    private UPDATE_PERIOD = 0.5
    private HOURS_IN_DAY = 24.
    //==========================================
    private FOG_MIN = 0 // пороговый низ тумана
    private FOG_MAX = 4000 // пороговый верх тумана
    private FOG_DENSITY = 80. // плотность
    //==========================================
    //0.
    private NIGHT_TIME = 0.
    private NIGHT_R = 5.
    private NIGHT_G = 7.
    private NIGHT_B = 7.
    private NIGHT_DENSITY = 100.
    private NIGHT_FOG_MAX = 3800.
    // 2.
    private MIDNIGHT_TIME = 2.
    private MIDNIGHT_R = 9.
    private MIDNIGHT_G = 12.
    private MIDNIGHT_B = 20.
    private MIDNIGHT_DENSITY = 120.
    private MIDNIGHT_FOG_MAX = 3500.
    //6.
    private MORNING_TIME = 6.
    private MORNING_R = 63.
    private MORNING_G = 50.
    private MORNING_B = 30.
    private MORNING_DENSITY = 90.
    private MORNING_FOG_MAX = 3900.
    //12.
    private DAY_TIME = 12.
    private DAY_R = 90.
    private DAY_G = 80.
    private DAY_B = 80.
    private DAY_DENSITY = 80.
    private DAY_FOG_MAX = 4100.
    //18.
    private EVENING_TIME = 18.
    private EVENING_R = 85.
    private EVENING_G = 65.
    private EVENING_B = 50.
    private EVENING_DENSITY = 85.
    private EVENING_FOG_MAX = 3950.
код
library Fog initializer Init

#include "cj_types.j"

//globals
    private real CurrFogR = 100., CurrFogG = 100., CurrFogB = 100., FogMax = 4000., Density = 80
    private real Fog_R_Delta[4]
    private real Fog_G_Delta[4]
    private real Fog_B_Delta[4]
    private real Fog_Max_Delta[4]
    private real Fog_Density_Delta[4]
    private int CurrentDayStage
    //==========================================
    // реальное время за сутки / часов в сутках
    private constant real DELTA_TIME = (480. / HOURS_IN_DAY)
    
    
    enum (day_time_type) { EVENING, NIGHT, MIDNIGHT, MORNING, DAY }
    
    
define {
    private START_TIME = 12.
    private UPDATE_PERIOD = 0.5
    private HOURS_IN_DAY = 24.
    //==========================================
    private FOG_MIN = 0 // пороговый низ тумана
    private FOG_MAX = 4000 // пороговый верх тумана
    private FOG_DENSITY = 80. // плотность
    //==========================================
    //0.
    private NIGHT_TIME = 0.
    private NIGHT_R = 5.
    private NIGHT_G = 7.
    private NIGHT_B = 7.
    private NIGHT_DENSITY = 100.
    private NIGHT_FOG_MAX = 3800.
    // 2.
    private MIDNIGHT_TIME = 2.
    private MIDNIGHT_R = 9.
    private MIDNIGHT_G = 12.
    private MIDNIGHT_B = 20.
    private MIDNIGHT_DENSITY = 120.
    private MIDNIGHT_FOG_MAX = 3500.
    //6.
    private MORNING_TIME = 6.
    private MORNING_R = 63.
    private MORNING_G = 50.
    private MORNING_B = 30.
    private MORNING_DENSITY = 90.
    private MORNING_FOG_MAX = 3900.
    //12.
    private DAY_TIME = 12.
    private DAY_R = 90.
    private DAY_G = 80.
    private DAY_B = 80.
    private DAY_DENSITY = 80.
    private DAY_FOG_MAX = 4100.
    //18.
    private EVENING_TIME = 18.
    private EVENING_R = 85.
    private EVENING_G = 65.
    private EVENING_B = 50.
    private EVENING_DENSITY = 85.
    private EVENING_FOG_MAX = 3950.
}
//==============================
//2.00 - 6.00 голубой-оранжевый
//6.00 - 12.00 оранжевый-белый
//12.00 - 18.00 белый-оранжевый
//18.00 - 24.00 оранжевый-черный
//24.00 - 2.00 черный-голубой.
//==============================

    private void FogEngine(){
        real dt = GetFloatGameState(GAME_STATE_TIME_OF_DAY)
            if (dt >= EVENING_TIME and dt < EVENING_TIME + 0.05) {
                CurrentDayStage = EVENING
                CurrFogR = EVENING_R
                CurrFogG = EVENING_G
                CurrFogB = EVENING_B
                FogMax = EVENING_FOG_MAX
                Density = EVENING_DENSITY
                SetTerrainFogEx(0, FOG_MIN, EVENING_FOG_MAX, EVENING_DENSITY, EVENING_R, EVENING_G, EVENING_B)
            }
            elseif (dt >= NIGHT_TIME and dt < NIGHT_TIME + 0.05) {
                CurrentDayStage = NIGHT
                CurrFogR = NIGHT_R
                CurrFogG = NIGHT_G
                CurrFogB = NIGHT_B
                FogMax = NIGHT_FOG_MAX
                Density = NIGHT_DENSITY
                SetTerrainFogEx(0, FOG_MIN, NIGHT_FOG_MAX, NIGHT_DENSITY, NIGHT_R, NIGHT_G, NIGHT_B)
            }
            elseif (dt >= MIDNIGHT_TIME and dt < MIDNIGHT_TIME + 0.05) {
                CurrentDayStage = MIDNIGHT
                CurrFogR = MIDNIGHT_R
                CurrFogG = MIDNIGHT_G
                CurrFogB = MIDNIGHT_B
                FogMax = MIDNIGHT_FOG_MAX
                Density = MIDNIGHT_DENSITY
                SetTerrainFogEx(0, FOG_MIN, MIDNIGHT_FOG_MAX, MIDNIGHT_DENSITY, MIDNIGHT_R, MIDNIGHT_G, MIDNIGHT_B)
            }
            elseif (dt >= MORNING_TIME and dt < MORNING_TIME + 0.05) {
                CurrentDayStage = MORNING
                CurrFogR = MORNING_R
                CurrFogG = MORNING_G
                CurrFogB = MORNING_B
                FogMax = MORNING_FOG_MAX
                Density = MORNING_DENSITY
                SetTerrainFogEx(0, FOG_MIN, MORNING_FOG_MAX, MORNING_DENSITY, MORNING_R, MORNING_G, MORNING_B)
            }
            elseif (dt >= DAY_TIME and dt < DAY_TIME + 0.05) {
                CurrentDayStage = DAY
                CurrFogR = DAY_R
                CurrFogG = DAY_G
                CurrFogB = DAY_B
                FogMax = DAY_FOG_MAX
                Density = DAY_DENSITY
                SetTerrainFogEx(0, FOG_MIN, DAY_FOG_MAX, DAY_DENSITY, DAY_R, DAY_G, DAY_B)
            }
            CurrFogR += Fog_R_Delta[CurrentDayStage]
            CurrFogG += Fog_G_Delta[CurrentDayStage]
            CurrFogB += Fog_B_Delta[CurrentDayStage]
            FogMax += Fog_Max_Delta[CurrentDayStage]
            Density += Fog_Density_Delta[CurrentDayStage]
        SetTerrainFogEx(0, FOG_MIN, FogMax, Density, (CurrFogR)*0.01, (CurrFogG)*0.01, (CurrFogB)*0.01)
    }
    
    
    private void SetupFogDelta() {
    
        // EVENING
        if (EVENING_TIME < NIGHT_TIME and NIGHT_TIME <= HOURS_IN_DAY) {
            Fog_R_Delta[EVENING] = (NIGHT_R - EVENING_R) / (((NIGHT_TIME - EVENING_TIME) * DELTA_TIME) / UPDATE_PERIOD)
            Fog_G_Delta[EVENING] = (NIGHT_G - EVENING_G) / (((NIGHT_TIME - EVENING_TIME) * DELTA_TIME) / UPDATE_PERIOD)
            Fog_B_Delta[EVENING] = (NIGHT_B - EVENING_B) / (((NIGHT_TIME - EVENING_TIME) * DELTA_TIME) / UPDATE_PERIOD)
            Fog_Max_Delta[EVENING] = (NIGHT_FOG_MAX - EVENING_FOG_MAX) / (((NIGHT_TIME - EVENING_TIME) * DELTA_TIME) / UPDATE_PERIOD)
            Fog_Density_Delta[EVENING] = (NIGHT_DENSITY - EVENING_DENSITY) / (((NIGHT_TIME - EVENING_TIME) * DELTA_TIME) / UPDATE_PERIOD)
        }
        else {
            Fog_R_Delta[EVENING] = (NIGHT_R - EVENING_R) / ((((NIGHT_TIME + HOURS_IN_DAY) - EVENING_TIME) * DELTA_TIME) / UPDATE_PERIOD)
            Fog_G_Delta[EVENING] = (NIGHT_G - EVENING_G) / ((((NIGHT_TIME + HOURS_IN_DAY) - EVENING_TIME) * DELTA_TIME) / UPDATE_PERIOD)
            Fog_B_Delta[EVENING] = (NIGHT_B - EVENING_B) / ((((NIGHT_TIME + HOURS_IN_DAY) - EVENING_TIME) * DELTA_TIME) / UPDATE_PERIOD)
            Fog_Max_Delta[EVENING] = (NIGHT_FOG_MAX - EVENING_FOG_MAX) / ((((NIGHT_TIME + HOURS_IN_DAY) - EVENING_TIME) * DELTA_TIME) / UPDATE_PERIOD)
            Fog_Density_Delta[EVENING] = (NIGHT_DENSITY - EVENING_DENSITY) / ((((NIGHT_TIME + HOURS_IN_DAY) - EVENING_TIME) * DELTA_TIME) / UPDATE_PERIOD)
        }
        
        // NIGHT
        Fog_R_Delta[NIGHT] = (MIDNIGHT_R - NIGHT_R) / (((MIDNIGHT_TIME - NIGHT_TIME) * DELTA_TIME) / UPDATE_PERIOD)
        Fog_G_Delta[NIGHT] = (MIDNIGHT_G - NIGHT_G) / (((MIDNIGHT_TIME - NIGHT_TIME) * DELTA_TIME) / UPDATE_PERIOD)
        Fog_B_Delta[NIGHT] = (MIDNIGHT_B - NIGHT_B) / (((MIDNIGHT_TIME - NIGHT_TIME) * DELTA_TIME) / UPDATE_PERIOD)
        Fog_Max_Delta[NIGHT] = (MIDNIGHT_FOG_MAX - NIGHT_FOG_MAX) / (((MIDNIGHT_TIME - NIGHT_TIME) * DELTA_TIME) / UPDATE_PERIOD)
        Fog_Density_Delta[NIGHT] = (MIDNIGHT_DENSITY - NIGHT_DENSITY) / (((MIDNIGHT_TIME - NIGHT_TIME) * DELTA_TIME) / UPDATE_PERIOD)
    
        // MIDNIGHT
        Fog_R_Delta[MIDNIGHT] = (MORNING_R - MIDNIGHT_R) / (((MORNING_TIME - MIDNIGHT_TIME) * DELTA_TIME) / UPDATE_PERIOD)
        Fog_G_Delta[MIDNIGHT] = (MORNING_G - MIDNIGHT_G) / (((MORNING_TIME - MIDNIGHT_TIME) * DELTA_TIME) / UPDATE_PERIOD)
        Fog_B_Delta[MIDNIGHT] = (MORNING_B - MIDNIGHT_B) / (((MORNING_TIME - MIDNIGHT_TIME) * DELTA_TIME) / UPDATE_PERIOD)
        Fog_Max_Delta[MIDNIGHT] = (MORNING_FOG_MAX - MIDNIGHT_FOG_MAX) / (((MORNING_TIME - MIDNIGHT_TIME) * DELTA_TIME) / UPDATE_PERIOD)
        Fog_Density_Delta[MIDNIGHT] = (MORNING_DENSITY - MIDNIGHT_DENSITY) / (((MORNING_TIME - MIDNIGHT_TIME) * DELTA_TIME) / UPDATE_PERIOD)
        
        // MORNING
        Fog_R_Delta[MORNING] = (DAY_R - MORNING_R) / (((DAY_TIME - MORNING_TIME) * DELTA_TIME) / UPDATE_PERIOD) 
        Fog_G_Delta[MORNING] = (DAY_G - MORNING_G) / (((DAY_TIME - MORNING_TIME) * DELTA_TIME) / UPDATE_PERIOD)
        Fog_B_Delta[MORNING] = (DAY_B - MORNING_B) / (((DAY_TIME - MORNING_TIME) * DELTA_TIME) / UPDATE_PERIOD)
        Fog_Max_Delta[MORNING] = (DAY_FOG_MAX - MORNING_FOG_MAX) / (((DAY_TIME -  MORNING_TIME) * DELTA_TIME) / UPDATE_PERIOD)
        Fog_Density_Delta[MORNING] = (DAY_DENSITY - MORNING_DENSITY) / (((DAY_TIME - MORNING_TIME) * DELTA_TIME) / UPDATE_PERIOD)
        
        // DAY
        Fog_R_Delta[DAY] = (EVENING_R - DAY_R) / (((EVENING_TIME - DAY_TIME) * DELTA_TIME) / UPDATE_PERIOD)
        Fog_G_Delta[DAY] = (EVENING_G - DAY_G) / (((EVENING_TIME - DAY_TIME) * DELTA_TIME) / UPDATE_PERIOD)
        Fog_B_Delta[DAY] = (EVENING_B - DAY_B) / (((EVENING_TIME - DAY_TIME) * DELTA_TIME) / UPDATE_PERIOD)
        Fog_Max_Delta[DAY] = (EVENING_FOG_MAX - DAY_FOG_MAX) / (((EVENING_TIME - DAY_TIME) * DELTA_TIME) / UPDATE_PERIOD)
        Fog_Density_Delta[DAY] = (EVENING_DENSITY - DAY_DENSITY) / (((EVENING_TIME - DAY_TIME) * DELTA_TIME) / UPDATE_PERIOD)

    }

    
    void ChangeGameTime(real time){
        real offset
            SetFloatGameState(GAME_STATE_TIME_OF_DAY, time)
                if (time >= NIGHT_TIME and time < MIDNIGHT_TIME) {
                    offset = ((time - NIGHT_TIME) * DELTA_TIME)
                        if offset > 0.
                            CurrFogR = offset * Fog_R_Delta[NIGHT]
                            CurrFogG = offset * Fog_G_Delta[NIGHT]
                            CurrFogB = offset * Fog_B_Delta[NIGHT]
                            FogMax = offset * Fog_Max_Delta[NIGHT]
                            Density = offset * Fog_Density_Delta[NIGHT]
                        else {
                            CurrFogR = NIGHT_R
                            CurrFogG = NIGHT_G
                            CurrFogB = NIGHT_B
                            FogMax = NIGHT_FOG_MAX
                            Density = NIGHT_DENSITY
                        }
                    CurrentDayStage = NIGHT
                }
                elseif (time >= MIDNIGHT_TIME and time < MORNING_TIME) {
                    offset = ((time - MIDNIGHT_TIME) * DELTA_TIME)
                        if offset > 0.
                            CurrFogR = offset * Fog_R_Delta[MIDNIGHT]
                            CurrFogG = offset * Fog_G_Delta[MIDNIGHT]
                            CurrFogB = offset * Fog_B_Delta[MIDNIGHT]
                            FogMax = offset * Fog_Max_Delta[MIDNIGHT]
                            Density = offset * Fog_Density_Delta[MIDNIGHT]
                            
                        else {
                            CurrFogR = MIDNIGHT_R
                            CurrFogG = MIDNIGHT_G
                            CurrFogB = MIDNIGHT_B
                            FogMax = MIDNIGHT_FOG_MAX
                            Density = MIDNIGHT_DENSITY
                        }
                    CurrentDayStage = MIDNIGHT
                }
                elseif (time >= MORNING_TIME and time < DAY_TIME) {
                    offset = ((time - MORNING_TIME) * DELTA_TIME)
                        if offset > 0.
                            CurrFogR = offset * Fog_R_Delta[MORNING]
                            CurrFogG = offset * Fog_G_Delta[MORNING]
                            CurrFogB = offset * Fog_B_Delta[MORNING]
                            FogMax = offset * Fog_Max_Delta[MORNING]
                            Density = offset * Fog_Density_Delta[MORNING]
                            
                        else {
                            CurrFogR = MORNING_R
                            CurrFogG = MORNING_G
                            CurrFogB = MORNING_B
                            FogMax = MORNING_FOG_MAX
                            Density = MORNING_DENSITY
                        }
                    CurrentDayStage = MORNING
                }
                elseif (time >= DAY_TIME and time < EVENING_TIME) {
                    offset = ((time - DAY_TIME) * DELTA_TIME)
                        if offset > 0.
                            CurrFogR = offset * Fog_R_Delta[DAY]
                            CurrFogG = offset * Fog_G_Delta[DAY]
                            CurrFogB = offset * Fog_B_Delta[DAY]
                            FogMax = offset * Fog_Max_Delta[DAY]
                            Density = offset * Fog_Density_Delta[DAY]
                            
                        else {
                            CurrFogR = DAY_R
                            CurrFogG = DAY_G
                            CurrFogB = DAY_B
                            FogMax = DAY_FOG_MAX
                            Density = DAY_DENSITY
                        }
                    CurrentDayStage = DAY
                }
                elseif time >= EVENING_TIME {
                    offset = ((time - EVENING_TIME) * DELTA_TIME)
                        if offset > 0.
                            CurrFogR = offset * Fog_R_Delta[EVENING]
                            CurrFogG = offset * Fog_G_Delta[EVENING]
                            CurrFogB = offset * Fog_B_Delta[EVENING]
                            FogMax = offset * Fog_Max_Delta[EVENING]
                            Density = offset * Fog_Density_Delta[EVENING]
                            
                        else {
                            CurrFogR = EVENING_R
                            CurrFogG = EVENING_G
                            CurrFogB = EVENING_B
                            FogMax = EVENING_FOG_MAX
                            Density = EVENING_DENSITY
                        }
                    CurrentDayStage = EVENING
                }
            SetTerrainFogEx(0, FOG_MIN, FogMax, Density, CurrFogR, CurrFogG, CurrFogB)
    }

    private void Init(){
        SetupFogDelta()
        ChangeGameTime(START_TIME)
        TimerStart(CreateTimer(), UPDATE_PERIOD, true, function FogEngine)
    }

endlibrary
Простенькая система цветного тумана для придания атмосферы карте. Настройки позволяют менять цвет и плоность тумана на протяжении различных дневных отрезков. Имеет одну юзабельную функцию
ChangeGameTime(real time)
Устанавливает время игры. Следует пользоваться ею при нужде смены времени.

Показан только небольшой набор комментариев вокруг указанного. Перейти к актуальным.
0
6
7 лет назад
0
Что-то как-то ничего особого. Ну дождик, ну туман
2
26
7 лет назад
2
Basile2:
Что-то как-то ничего особого. Ну дождик, ну туман
фишка в настройках и области применения
0
21
7 лет назад
0
Что-то как-то ничего особого. Ну дождик, ну туман
Готовые для использования.
5
33
7 лет назад
5
Я в морлоках делал мега погоду) Помню, она сильно тормозила, если ее на всю карту сразу применить. Я резал карту на регионы, и циклом со временем все менял. Еще помню, что два погодных эффекта в регионе не уживались из-за равкода, один потом не удалялся. Еще у меня дождь становился то сильнее, то слабее. Еще автоматом настраивалась погоду под климат, брался тупо тайлсет в центре карты. Еще были кастомные эффекты с слк таблице, и туман к ним добавлялся. И звуки)
Я в картах кампании у нас была моделька капель на воде, и мы ею мостили все водоемы, и во время дождя включали ей анимацию...
И вся погода, с помощью даммикастера с аурой давала глобальный эффект, дождь ускорял морлоков. но замедлял людей и т. д.
0
26
7 лет назад
0
ADOLF:
Я в морлоках делал мега погоду) Помню, она сильно тормозила, если ее на всю карту сразу применить. Я резал карту на регионы, и циклом со временем все менял. Еще помню, что два погодных эффекта в регионе не уживались из-за равкода, один потом не удалялся. Еще у меня дождь становился то сильнее, то слабее. Еще автоматом настраивалась погоду под климат, брался тупо тайлсет в центре карты. Еще были кастомные эффекты с слк таблице, и туман к ним добавлялся. И звуки)
Я в картах кампании у нас была моделька капель на воде, и мы ею мостили все водоемы, и во время дождя включали ей анимацию...
мощно) я бы тоже хотел звуки различные добавить, проблема лишь в нахождении их. пока мои поиски ничем особым не увенчались
0
33
7 лет назад
0
Берите из морлоков, можно запустить любую милишную карту или карту кампании.
Показан только небольшой набор комментариев вокруг указанного. Перейти к актуальным.
Чтобы оставить комментарий, пожалуйста, войдите на сайт.