UIPopupScriptSceneManager.c

См. документацию.

class UIPopupScriptSceneManager extends UIPopupScript
{
    private ButtonWidget        m_BtnCancel;
    private ButtonWidget        m_BtnSceneNew;
    private ButtonWidget        m_BtnSceneLoad;
    private ButtonWidget        m_BtnSceneRename;
    private ButtonWidget        m_BtnSceneDuplicate;
    private ButtonWidget        m_BtnSceneDelete;
    private TextListboxWidget   m_LstListScenes;
    
    private static const int m_DaysInMonth[12] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };
    
    private ButtonWidget    m_BtnSave;
    
    private TextWidget        m_TxtWeatherTime;
    
    private SliderWidget    m_SldStartTime;
    private TextWidget        m_TxtStartTimeValue;
    private SliderWidget    m_SldStartDay;
    private TextWidget        m_TxtStartDayValue;
    private SliderWidget    m_SldOvercast;
    private TextWidget        m_TxtOvercastValue;
    private SliderWidget    m_SldRain;
    private TextWidget        m_TxtRainValue;
    private SliderWidget    m_SldFog;
    private TextWidget        m_TxtFogValue;
    private SliderWidget    m_SldWindForce;
    private TextWidget        m_TxtWindForceValue;
    
    private int             m_OrigYear;
    private int             m_OrigMonth;
    private int             m_OrigDay;
    private int             m_OrigHour;
    private int             m_OrigMinute;
    private float           m_OrigOvercast;
    private float           m_OrigRain;
    private float           m_OrigFog;
    private float           m_OrigWindForce;
    
    private int             m_CurrYear;
    private int             m_CurrMonth;
    private int             m_CurrDay;
    private int             m_CurrHour;
    private int             m_CurrMinute;
    private float           m_CurrOvercast;
    private float           m_CurrRain;
    private float           m_CurrFog;
    private float           m_CurrWindForce;
    
    //================================================
    // UIPopupScriptSceneManager
    //================================================  
    void UIPopupScriptSceneManager(Widget wgt)
    {
        m_BtnCancel          = ButtonWidget.Cast( wgt.FindAnyWidget("btn_ppp_sm_cancel") );
        m_BtnSceneNew      = ButtonWidget.Cast( wgt.FindAnyWidget("btn_ppp_sm_mission_new") );
        m_BtnSceneLoad        = ButtonWidget.Cast( wgt.FindAnyWidget("btn_ppp_sm_mission_load") );
        m_BtnSceneRename    = ButtonWidget.Cast( wgt.FindAnyWidget("btn_ppp_sm_mission_rename") );
        m_BtnSceneDelete    = ButtonWidget.Cast( wgt.FindAnyWidget("btn_ppp_sm_mission_delete") );
        m_BtnSceneDuplicate  = ButtonWidget.Cast( wgt.FindAnyWidget("btn_ppp_sm_mission_duplicate") );
        
        m_LstListScenes  = TextListboxWidget.Cast( wgt.FindAnyWidget("tls_ppp_sm_scene_list") );
        
        m_BtnSave          = ButtonWidget.Cast( wgt.FindAnyWidget("btn_ppp_st_save") );
        
        m_TxtWeatherTime    = TextWidget.Cast( wgt.FindAnyWidget("txt_ppp_st_w_time_value") );
        
        m_SldStartTime        = SliderWidget.Cast( wgt.FindAnyWidget("sld_ppp_st_start_time") );
        m_TxtStartTimeValue  = TextWidget.Cast( wgt.FindAnyWidget("txt_ppp_st_start_time_value") );
        
        m_SldStartDay      = SliderWidget.Cast( wgt.FindAnyWidget("sld_ppp_st_start_day") );
        m_TxtStartDayValue    = TextWidget.Cast( wgt.FindAnyWidget("txt_ppp_st_start_day_value") );
        
        m_SldOvercast      = SliderWidget.Cast( wgt.FindAnyWidget("sld_ppp_st_overcast") );
        m_TxtOvercastValue    = TextWidget.Cast( wgt.FindAnyWidget("txt_ppp_st_overcast_value") );
        
        m_SldRain          = SliderWidget.Cast( wgt.FindAnyWidget("sld_ppp_st_rain") );
        m_TxtRainValue        = TextWidget.Cast( wgt.FindAnyWidget("txt_ppp_st_rain_value") );
        
        m_SldFog            = SliderWidget.Cast( wgt.FindAnyWidget("sld_ppp_st_fog") );
        m_TxtFogValue      = TextWidget.Cast( wgt.FindAnyWidget("txt_ppp_st_fog_value") );
        
        m_SldWindForce        = SliderWidget.Cast( wgt.FindAnyWidget("sld_ppp_st_wind_force") );
        m_TxtWindForceValue  = TextWidget.Cast( wgt.FindAnyWidget("txt_ppp_st_wind_force_value") );
    }
 
    void ~UIPopupScriptSceneManager()
    {
        GetGame().GetUpdateQueue(CALL_CATEGORY_SYSTEM).Remove(this.OnUpdate);
    }
    
    //================================================
    // OnClick
    //================================================  
    override bool OnClick(Widget w, int x, int y, int button)
    {
        super.OnClick(w, x, y, button);
        
        string scene_name;
        PluginSceneManager editor;
        
        if ( w == m_BtnCancel )
        {
            GetGame().GetWorld().SetDate( m_OrigYear, m_OrigMonth, m_OrigDay, m_OrigHour, m_OrigMinute );
 
            Weather weather = GetGame().GetWeather();
            weather.GetOvercast().Set( m_OrigOvercast, 0, 1000 );
            weather.GetRain().Set( m_OrigRain, 0, 1000 );
            weather.GetFog().Set( m_OrigFog, 0, 1000 );
            weather.SetWindSpeed( m_OrigWindForce );
 
            PopupBack();
            return true;
        }
        else if ( w == m_BtnSceneNew )
        {
            PopupOpen(SceneEditorMenu.POPUP_ID_SCENE_NEW, NULL);
            
            return true;
        }
        else if ( w == m_BtnSceneLoad )
        {
            if ( m_LstListScenes.GetSelectedRow() != -1 )
            {
                m_LstListScenes.GetItemText( m_LstListScenes.GetSelectedRow(), 0, scene_name );
                editor = PluginSceneManager.Cast( GetPlugin(PluginSceneManager) );
                
                editor.SceneLoad(scene_name);
                PopupBack();
                
                return true;
            }
        }
        else if ( w == m_BtnSceneRename )
        {
            m_LstListScenes.GetItemText( m_LstListScenes.GetSelectedRow(), 0, scene_name );
            
            UIPopupScriptSceneRename popup_rename = UIPopupScriptSceneRename.Cast( PopupOpen(SceneEditorMenu.POPUP_ID_SCENE_RENAME, NULL) );
            popup_rename.SetRenameName(scene_name);
            
            return true;
        }
        else if ( w == m_BtnSceneDuplicate )
        {
            if ( m_LstListScenes.GetSelectedRow() != -1 )
            {
                m_LstListScenes.GetItemText( m_LstListScenes.GetSelectedRow(), 0, scene_name );
                editor = PluginSceneManager.Cast( GetPlugin(PluginSceneManager) );
                
                editor.SceneDuplicate(scene_name);
                UpdateSceneList();
                
                return true;
            }
        }
        else if ( w == m_BtnSceneDelete )
        {
            if ( m_LstListScenes.GetSelectedRow() != -1 )
            {
                m_LstListScenes.GetItemText( m_LstListScenes.GetSelectedRow(), 0, scene_name );
                editor = PluginSceneManager.Cast( GetPlugin(PluginSceneManager) );
                
                editor.SceneDelete(scene_name);
                
                if ( editor.SceneCanDelete(scene_name) )
                {
                    UIPopupScriptSceneDelete popup_delete = UIPopupScriptSceneDelete.Cast( PopupOpen(SceneEditorMenu.POPUP_ID_SCENE_DELETE, NULL) );
                    popup_delete.SetDeleteName(scene_name);
                }
                else
                {
                    UIPopupScriptNotify popup_notify = UIPopupScriptNotify.Cast( PopupOpen(SceneEditorMenu.POPUP_ID_NOTIFY, NULL) );
                    popup_notify.SetLabelText("You cant delete current loaded scene!");
                }           
                
                UpdateSceneList();
                return true;
            }       
        }
        else if ( w == m_BtnSave )
        {       
            m_OrigYear = m_CurrYear;
            m_OrigMonth = m_CurrMonth;
            m_OrigDay = m_CurrDay;
            m_OrigHour = m_CurrHour;
            m_OrigMinute = m_CurrMinute;
            m_OrigOvercast = m_CurrOvercast;
            m_OrigRain = m_CurrRain;
            m_OrigFog = m_CurrFog;
            m_OrigWindForce = m_CurrWindForce;
            
            editor = PluginSceneManager.Cast( GetPlugin(PluginSceneManager) );
            editor.SetWeather(m_CurrOvercast, m_CurrRain, m_CurrFog, m_CurrWindForce);
            editor.SetDate(m_CurrYear, m_CurrMonth, m_CurrDay, m_CurrHour, m_CurrMinute);
            editor.SceneSave();
            
            PopupBack();
            
            return true;
        }
        
        return false;
    }
    
    override bool OnChange(Widget w, int x, int y, bool finished)
    {
        if ( w == m_SldStartTime )
        {       
            float slider_value_start_time = m_SldStartTime.GetCurrent() * 0.01;       
            float start_time_f = slider_value_start_time * 1439;
            int start_time = start_time_f;
            m_CurrHour = start_time / 60;
            m_CurrMinute = start_time % 60;
            
            UpdateSliderStartTime( m_CurrHour, m_CurrMinute );
            
            GetGame().GetWorld().SetDate( m_CurrYear, m_CurrMonth, m_CurrDay, m_CurrHour, m_CurrMinute );
            
            return true;
        }
        else if ( w == m_SldStartDay )
        {       
            float slider_value_start_day = m_SldStartDay.GetCurrent();
            float start_day_f = slider_value_start_day * 3.64 + 1;
            int start_day = start_day_f;
            
            for ( int i = 0; i < 12; i++ )
            {
                int days = m_DaysInMonth[i];
                if ( start_day <= days )
                {
                    m_CurrMonth = i+1;
                    m_CurrDay = start_day;
                    break;
                }
                else
                {
                    start_day -= days;
                }
            }
            
            UpdateSliderStartDay( m_CurrMonth, m_CurrDay );
            
            GetGame().GetWorld().SetDate( m_CurrYear, m_CurrMonth, m_CurrDay, m_CurrHour, m_CurrMinute );
            
            return true;
        }
        else if ( w == m_SldOvercast )
        {       
            m_CurrOvercast = m_SldOvercast.GetCurrent() * 0.01;      
            GetGame().GetWeather().GetOvercast().Set( m_CurrOvercast, 0, 1000 );
 
            UpdateSliderOvercast();
            
            return true;
        }
        else if ( w == m_SldRain )
        {       
            m_CurrRain = m_SldRain.GetCurrent() * 0.01;      
            GetGame().GetWeather().GetRain().Set( m_CurrRain, 0, 1000 );
            
            UpdateSliderRain();
            
            return true;
        }
        else if ( w == m_SldFog )
        {       
            m_CurrFog = m_SldFog.GetCurrent() * 0.01;      
            GetGame().GetWeather().GetFog().Set( m_CurrFog, 0, 1000 );
 
            UpdateSliderFog();
            
            return true;
        }
        else if ( w == m_SldWindForce )
        {       
            float wind_slider = m_SldWindForce.GetCurrent() * 0.01;
            m_CurrWindForce = GetGame().GetWeather().GetWindMaximumSpeed() * wind_slider;
            GetGame().GetWeather().SetWindSpeed( m_CurrWindForce );
 
            UpdateSliderWindForce();
            
            return true;
        }
        
        return false;
    }
 
    //================================================
    // UpdateSceneList
    //================================================  
    void UpdateSceneList()
    {
        m_LstListScenes.ClearItems();
        
        PluginSceneManager editor = PluginSceneManager.Cast( GetPlugin(PluginSceneManager) );
        
        TStringArray scene_list = editor.GetSceneList();
        string loaded_scene_name = editor.SceneGetName();
        
        for ( int i = 0; i < scene_list.Count(); ++i )
        {
            string scene_name = scene_list.Get(i);
            
            m_LstListScenes.AddItem(scene_name, NULL, 0);
            
            if ( scene_name == loaded_scene_name )
            {
                m_LstListScenes.SelectRow(i);
            }
        }
    }
 
    //================================================
    // UpdateSceneList
    //================================================  
    override void OnOpen(Param param)
    {
        //Log("Poup Scene Manager OnOpen");
        
        UpdateSceneList();
        GetGame().GetWorld().GetDate( m_OrigYear, m_OrigMonth, m_OrigDay, m_OrigHour, m_OrigMinute );
 
        Weather weather = GetGame().GetWeather();
        m_OrigOvercast = weather.GetOvercast().GetActual();
        m_OrigRain = weather.GetRain().GetActual();
        m_OrigFog = weather.GetFog().GetActual();
        m_OrigWindForce = weather.GetWindSpeed();
 
        m_CurrYear = m_OrigYear;
        m_CurrMonth = m_OrigMonth;
        m_CurrDay = m_OrigDay;
        m_CurrHour = m_OrigHour;
        m_CurrMinute = m_OrigMinute;
        m_CurrOvercast = m_OrigOvercast;
        m_CurrRain = m_OrigRain;
        m_CurrFog = m_OrigFog;
        m_CurrWindForce = m_OrigWindForce;
        
        Print( "Year" );
        Print( m_CurrYear );
        
        GetGame().GetUpdateQueue(CALL_CATEGORY_SYSTEM).Insert(this.OnUpdate);
                
        ResetSliders();
    }
    
    //================================================
    // OnClose
    //================================================  
    override void OnClose()
    {       
        GetGame().GetUpdateQueue(CALL_CATEGORY_SYSTEM).Remove(this.OnUpdate);
    }
    
    //================================================
    // OnUpdate
    //================================================  
    void OnUpdate()
    {
        m_TxtWeatherTime.SetText(GetGame().GetWeather().GetTime().ToString());
    }
    
    //================================================
    // ResetSliders
    //================================================  
    void ResetSliders()
    {
        int year, month, day, hour, minute;
        GetGame().GetWorld().GetDate( year, month, day, hour, minute );
        m_SldStartTime.SetCurrent( ((hour * 60) + minute) / 14.39 );
        UpdateSliderStartTime( hour, minute );
        
        float start_day = day;
        int month_tmp = month;
        while ( month_tmp > 1 )
        {
            month_tmp--;
            start_day += m_DaysInMonth[month];
        }
        m_SldStartDay.SetCurrent( start_day / 3.64 );
        UpdateSliderStartDay( month, day );
 
        Weather weather = GetGame().GetWeather();
 
        m_SldOvercast.SetCurrent(weather.GetOvercast().GetActual() * 100);
        UpdateSliderOvercast();
 
        m_SldRain.SetCurrent(weather.GetRain().GetActual() * 100);
        UpdateSliderRain();
 
        m_SldFog.SetCurrent(weather.GetFog().GetActual() * 100);
        UpdateSliderFog();
 
        float wind_slider = m_SldWindForce.GetCurrent() * 0.01;
        m_CurrWindForce = weather.GetWindMaximumSpeed() * wind_slider;
        weather.SetWindSpeed( m_CurrWindForce );
        UpdateSliderWindForce();
    }
    
    void UpdateSliderStartTime( int hour, int minute )
    {
        string label_text = hour.ToStringLen(2) + ":" + minute.ToStringLen(2);
        m_TxtStartTimeValue.SetText( label_text );
    }
 
    void UpdateSliderStartDay( int month, int day )
    {
        string label_text = day.ToString() + "." + month.ToString() + ". " + m_CurrYear.ToString();
        m_TxtStartDayValue.SetText( label_text );
    }
 
    void UpdateSliderOvercast()
    {
        string label_text = m_SldOvercast.GetCurrent().ToString()+"%";
        m_TxtOvercastValue.SetText( label_text );
    }
 
    void UpdateSliderRain()
    {
        string label_text = m_SldRain.GetCurrent().ToString()+"%";
        m_TxtRainValue.SetText( label_text );
    }
 
    void UpdateSliderFog()
    {
        string label_text = m_SldFog.GetCurrent().ToString()+"%";
        m_TxtFogValue.SetText( label_text );
    }
 
    void UpdateSliderWindForce()
    {
        string label_text = m_CurrWindForce.ToString()+"ms";
        m_TxtWindForceValue.SetText( label_text );
    }
}