lui_shared.gsc

Go to the documentation of this file.

#using scripts\codescripts\struct;
 
#using scripts\shared\array_shared;
#using scripts\shared\callbacks_shared;
#using scripts\shared\string_shared;
#using scripts\shared\system_shared;
#using scripts\shared\util_shared;
#using scripts\shared\flag_shared;
#using scripts\shared\flagsys_shared;
 
#insert scripts\shared\shared.gsh;
 
#namespace lui;
 
#precache( "eventstring", "show_perk_notification" );
 
#precache( "lui_menu", "HudElementText" );
#precache( "lui_menu", "HudElementImage" );
#precache( "lui_menu", "HudElementTimer" );
#precache( "lui_menu", "FullScreenBlack" );
#precache( "lui_menu", "FullScreenWhite" );
#precache( "lui_menu", "ScriptMessageDialog_Compact" );
#precache( "lui_menu", "FullBlack" ); // InitialBlack without the spinner
 
#precache( "lui_menu_data", "text" );
#precache( "lui_menu_data", "material" );
#precache( "lui_menu_data", "x" );
#precache( "lui_menu_data", "y" );
#precache( "lui_menu_data", "width" );
#precache( "lui_menu_data", "height" );
#precache( "lui_menu_data", "alpha" );
#precache( "lui_menu_data", "alignment" );
#precache( "lui_menu_data", "fadeOverTime" );
#precache( "lui_menu_data", "startAlpha" );
#precache( "lui_menu_data", "endAlpha" );
#precache( "lui_menu_data", "time" );
#precache( "lui_menu_data", "current_animation" );
#precache( "lui_menu_data", "red" );
#precache( "lui_menu_data", "green" );
#precache( "lui_menu_data", "blue" );
#precache( "lui_menu_data", "zRot" );
 
#precache( "lui_menu", "PiPMenu" );
#precache( "lui_menu", "FullscreenMovie" );
#precache( "lui_menu_data", "additive" );
#precache( "lui_menu_data", "movieName" );
#precache( "lui_menu_data", "showBlackScreen" );
#precache( "lui_menu_data", "looping" );
#precache( "lui_menu_data", "movieKey" );
 
#precache( "lui_menu_data", "title" );
#precache( "lui_menu_data", "description" );
 
‪REGISTER_SYSTEM( "lui_shared", &‪__init__, undefined )
 
function ‪__init__()
{
    ‪callback::on_spawned(&‪refresh_menu_values);
}
 
// Refresh all global lui variables for connecting players.
//
function private ‪refresh_menu_values()
{
    if ( !isdefined( level.lui_script_globals ) )
    {
        return;
    }
    
    a_str_menus = GetArrayKeys( level.lui_script_globals );
    for ( i = 0; i < a_str_menus.size; i++ )
    {
        str_menu = a_str_menus[i];
        a_str_vars = GetArrayKeys( level.lui_script_globals[str_menu] );
        for ( j = 0; j < a_str_vars.size; j++ )
        {
            str_var = a_str_vars[j];
            value = level.lui_script_globals[str_menu][str_var];
            self ‪set_value_for_player( str_menu, str_var, value );
        }
    }
}
 
function ‪play_animation( menu, str_anim )
{
    str_curr_anim = self GetLUIMenuData( menu, "current_animation" );
    str_new_anim = str_anim;
    
    // This is because if we set the anim name again to what it was before, it will not trigger the model subscription 
    // which will in turn not play the animation. This case is handled specially in lua, to check if its an empty string,
    // if so, play the same anim again.
    if ( isdefined( str_curr_anim ) && ( str_curr_anim == str_anim ) )
    {
        str_new_anim = "";  
    }
    
    self SetLUIMenuData( menu, "current_animation", str_new_anim );     
}
 
function ‪set_color( menu, color )
{
    self SetLUIMenuData( menu, "red", color[ 0 ] );
    self SetLUIMenuData( menu, "green", color[ 1 ] );
    self SetLUIMenuData( menu, "blue", color[ 2 ] );
}
 
// Set a LUI data model value for a specific player.
//
// Self == player
//
// Note: be sure to precache the lui_menu and the lui_menu_data for str_menu_id and str_variable_id respectively.
//
function ‪set_value_for_player( str_menu_id, str_variable_id, value )
{
    ‪DEFAULT( self.lui_script_menus, [] );
    ‪DEFAULT( self.lui_script_menus[str_menu_id], self OpenLuiMenu( str_menu_id ) );
        self SetLuiMenuData( self.lui_script_menus[str_menu_id], str_variable_id, value );
    }
 
// Set a LUI data model value for all players.
//
// Note: be sure to precache the lui_menu and the lui_menu_data for str_menu_id and str_variable_id respectively.
//
function ‪set_global( str_menu_id, str_variable_id, value )
{
    ‪DEFAULT( level.lui_script_globals, [] );
    ‪DEFAULT( level.lui_script_globals[str_menu_id], [] );
    
    level.lui_script_globals[ str_menu_id ][ str_variable_id ] = value;
 
    // If there are no players now, no worries--it'll automagically get assigned when they connect.
    //  
    if ( isdefined( level.players ) )
    {
        foreach( player in level.players )
        {
            player ‪set_value_for_player( str_menu_id, str_variable_id, value );
        }
    }
}
 
function ‪timer( n_time, str_endon, x, y, height )
{
    ‪DEFAULT( x, ‪SCREEN_WIDTH - 200 );
    ‪DEFAULT( y, 200 );
    ‪DEFAULT( height, 60 );
    
    lui = self OpenLUIMenu( "HudElementTimer" );
    self SetLUIMenuData( lui, "x", x );
    self SetLUIMenuData( lui, "y", y );
    self SetLUIMenuData( lui, "height", height );
    self SetLUIMenuData( lui, "time", GetTime() + ( n_time * 1000 ) );
    
    if ( isdefined( str_endon ) )
    {
        self ‪util::waittill_notify_or_timeout( str_endon, n_time );
    }
    else
    {
        wait n_time;
    }
    
    self CloseLUIMenu( lui );
}
 
function ‪prime_movie( str_movie, b_looping = false, str_key = "" )
{
    if ( self == level )
    {
        foreach ( player in level.players )
        {
            player PrimeMovie( str_movie, b_looping, str_key );
        }
    }
    else
    {
        player PrimeMovie( str_movie, b_looping, str_key );
    }
}
 
function ‪play_movie( str_movie, str_type, show_black_screen = false, b_looping = false, str_key = "" )
{
    if( str_type === "fullscreen" || str_type === "fullscreen_additive" )
    {
        b_hide_hud = true;
    }
    
    if ( self == level )
    {
        foreach ( player in level.players )
        {
            if( isdefined(b_hide_hud) )
            {
                player ‪flagsys::set( "playing_movie_hide_hud" );
                player ‪util::show_hud( 0 );
            }
            
            player thread ‪_play_movie_for_player( str_movie, str_type, show_black_screen, b_looping, str_key );
        }
        
        ‪array::wait_till( level.players, "movie_done" );
        
        if( isdefined(b_hide_hud) )
        {
            foreach ( player in level.players )
            {
                player ‪flagsys::clear( "playing_movie_hide_hud" );
                player ‪util::show_hud( 1 );
            }
        }
    }
    else
    {
        if( isdefined(b_hide_hud) )
        {
            self ‪flagsys::set( "playing_movie_hide_hud" );
            self ‪util::show_hud( 0 );
        }
        
        ‪_play_movie_for_player( str_movie, str_type, false, b_looping, str_key );
        
        if( isdefined(b_hide_hud) )
        {
            self ‪flagsys::clear( "playing_movie_hide_hud" );
            self ‪util::show_hud( 1 );
        }
    }
    
    
 
    level notify( "movie_done", str_type );
}
 
function private ‪_play_movie_for_player( str_movie, str_type, show_black_screen, b_looping, str_key )
{
    self endon("disconnect");
    str_menu = undefined;
    
    switch ( str_type )
    {
        case "fullscreen":
        case "fullscreen_additive":
            str_menu = "FullscreenMovie";
            break;
            
        case "pip":
            str_menu = "PiPMenu";
            break;
            
        default: AssertMsg( "Invalid movie type '" + str_type + "'." );
    }
    
    if( str_type == "pip" )
    {
        self playsoundtoplayer( "uin_pip_open", self );
    }
    
    lui_menu = self OpenLUIMenu( str_menu );
    if(isDefined(lui_menu))
    {
        self SetLUIMenuData( lui_menu, "movieName", str_movie );
        self SetLUIMenuData( lui_menu, "movieKey", str_key );
        self SetLUIMenuData( lui_menu, "showBlackScreen", show_black_screen );
        self SetLUIMenuData( lui_menu, "looping", b_looping );
        self SetLUIMenuData( lui_menu, "additive", 0 );
        
        if ( IsSubStr( str_type, "additive" ) )
        {
            self SetLUIMenuData( lui_menu, "additive", 1 );
        }
        
        while ( true )
        {
            self waittill( "menuresponse", menu, response );
                                        
            if ( ( menu == str_menu ) && ( response == "finished_movie_playback" ) )
            {
                if( str_type == "pip" )
                {
                    self playsoundtoplayer( "uin_pip_close", self );
                }
                
                self CloseLUIMenu( lui_menu );
                self notify( "movie_done" );
            }
        }
    }
}
 
function ‪play_movie_with_timeout( str_movie, str_type, ‪timeout, show_black_screen = false, b_looping = false, str_key = "" )
{
    if( str_type === "fullscreen" || str_type === "fullscreen_additive" )
    {
        b_hide_hud = true;
    }
    
    assert( self == level );
    
    foreach ( player in level.players )
    {
        if( isdefined(b_hide_hud) )
        {
            player ‪flagsys::set( "playing_movie_hide_hud" );
            player ‪util::show_hud( 0 );
        }
        
        player thread ‪_play_movie_for_player_with_timeout( str_movie, str_type, ‪timeout, show_black_screen, b_looping, str_key );
    }
    
    ‪array::wait_till( level.players, "movie_done" );
    
    if( isdefined(b_hide_hud) )
    {
        foreach ( player in level.players )
        {
            player ‪flagsys::clear( "playing_movie_hide_hud" );
            player ‪util::show_hud( 1 );
        }
    }
 
    level notify( "movie_done", str_type );
}
 
function private ‪_play_movie_for_player_with_timeout( str_movie, str_type, ‪timeout, show_black_screen, b_looping, str_key )
{
    self endon("disconnect");
    str_menu = undefined;
    
    switch ( str_type )
    {
        case "fullscreen":
        case "fullscreen_additive":
            str_menu = "FullscreenMovie";
            break;
            
        case "pip":
            str_menu = "PiPMenu";
            break;
            
        default: AssertMsg( "Invalid movie type '" + str_type + "'." );
    }
    
    if( str_type == "pip" )
    {
        self playsoundtoplayer( "uin_pip_open", self );
    }
    
    lui_menu = self OpenLUIMenu( str_menu );
    if(isDefined(lui_menu))
    {
        self SetLUIMenuData( lui_menu, "movieName", str_movie );
        self SetLUIMenuData( lui_menu, "movieKey", str_key );
        self SetLUIMenuData( lui_menu, "showBlackScreen", show_black_screen );
        self SetLUIMenuData( lui_menu, "looping", b_looping );
        self SetLUIMenuData( lui_menu, "additive", 0 );
        
        if ( IsSubStr( str_type, "additive" ) )
        {
            self SetLUIMenuData( lui_menu, "additive", 1 );
        }
        
        wait ‪timeout;
                                    
        if( str_type == "pip" )
        {
            self playsoundtoplayer( "uin_pip_close", self );
        }
        
        self CloseLUIMenu( lui_menu );
        self notify( "movie_done" );
    }
}
 
function ‪screen_flash( n_fadein_time, n_hold_time, n_fadeout_time, n_target_alpha = 1, v_color, b_force_close_menu = false )
{
    if ( self == level )
    {
        foreach ( player in level.players )
        {
            player thread ‪screen_flash( n_fadein_time, n_hold_time, n_fadeout_time, n_target_alpha, v_color, b_force_close_menu );
        }
    }
    else
    {
        self endon( "disconnect" );
        
        self ‪_screen_fade( n_fadein_time, n_target_alpha, 0, v_color, b_force_close_menu );
        wait n_hold_time;
        self ‪_screen_fade( n_fadeout_time, 0, n_target_alpha, v_color, b_force_close_menu );
    }
}
 
function ‪screen_fade( n_time, n_target_alpha = 1, n_start_alpha = 0, v_color, b_force_close_menu = false, str_menu_id  )
{
    if ( self == level )
    {
        foreach ( player in level.players )
        {
            player thread ‪_screen_fade( n_time, n_target_alpha, n_start_alpha, v_color, b_force_close_menu, str_menu_id );
        }
    }
    else
    {
        self thread ‪_screen_fade( n_time, n_target_alpha, n_start_alpha, v_color, b_force_close_menu, str_menu_id );
    }
}
 
function ‪screen_fade_out( n_time, v_color, str_menu_id )
{
    ‪screen_fade( n_time, 1, 0, v_color, false, str_menu_id );
    wait n_time;
}
 
function ‪screen_fade_in( n_time, v_color, str_menu_id )
{
    ‪screen_fade( n_time, 0, 1, v_color, true, str_menu_id );
    wait n_time;
}
 
function ‪screen_close_menu()
{
    if ( self == level )
    {
        foreach ( player in level.players )
        {
            player thread ‪_screen_close_menu();
        }
    }
    else
    {
        self thread ‪_screen_close_menu();
    }
}
 
function private ‪_screen_close_menu()
{
    self notify( "_screen_fade" );
    self endon( "_screen_fade" );
    self endon( "disconnect" );
    
    if ( isdefined( self.screen_fade_menus ) )
    {
        foreach ( str_menu_id, lui_menu in self.screen_fade_menus )
        {
            self CloseLUIMenu( lui_menu.lui_menu );
            self.screen_fade_menus[ str_menu_id ] = undefined;
        }
    }
}
 
function private ‪_screen_fade( n_time, n_target_alpha, n_start_alpha, v_color, b_force_close_menu, str_menu_id = "default" )
{
    self notify( "_screen_fade_" + str_menu_id );
    self endon( "_screen_fade_" + str_menu_id );
    
    self endon( "disconnect" );
    
    ‪DEFAULT( self.screen_fade_menus, [] );
    ‪DEFAULT( level.screen_fade_network_frame, 0 );
    ‪DEFAULT( v_color, ( 0, 0, 0 ) );
    
    n_time_ms = int( n_time * 1000 );
    
    str_menu = "FullScreenBlack";
    
    if ( IsString( v_color ) )
    {
        switch ( v_color )
        {
            case "black":
                v_color = ( 0, 0, 0 );
                break;
                
            case "white":
                v_color = ( 1, 1, 1 );
                break;
        }
    }
        
    lui_menu = "";
        
    if ( isdefined( self.screen_fade_menus[ str_menu_id ] ) )
    {
        /* Use current menu */
        
        s_menu = self.screen_fade_menus[ str_menu_id ];     
        lui_menu = s_menu.lui_menu;
        
        ‪_one_screen_fade_per_network_frame( s_menu ); // menu commands can't run on the same network frame
        
        /* Calculate the current alpha since we can't get it directly from the menu */
                        
        n_start_alpha = LerpFloat( s_menu.n_start_alpha, s_menu.n_target_alpha, GetTime() - s_menu.n_start_time );
    }
    else
    {
        lui_menu = self OpenLUIMenu( str_menu );
        
        self.screen_fade_menus[ str_menu_id ] = SpawnStruct();
        self.screen_fade_menus[ str_menu_id ].lui_menu = lui_menu;
    }
    
    self.screen_fade_menus[ str_menu_id ].n_start_alpha = n_start_alpha;    
    self.screen_fade_menus[ str_menu_id ].n_target_alpha = n_target_alpha;
    self.screen_fade_menus[ str_menu_id ].n_target_time = n_time_ms;
    self.screen_fade_menus[ str_menu_id ].n_start_time = GetTime();
    
    self ‪set_color( lui_menu, v_color );
        
    self SetLUIMenuData( lui_menu, "startAlpha", n_start_alpha );
    self SetLUIMenuData( lui_menu, "endAlpha", n_target_alpha );
    self SetLUIMenuData( lui_menu, "fadeOverTime", n_time_ms );
    
    if ( n_time > 0 )
    {
        wait n_time;
    }
    
    self SetLUIMenuData( lui_menu, "fadeOverTime", 0 );
        
    if ( b_force_close_menu || ( n_target_alpha == 0 ) )
    {
        if ( isdefined( self.screen_fade_menus[ str_menu_id ] ) )
        {
            self CloseLUIMenu( self.screen_fade_menus[ str_menu_id ].lui_menu );
        }
        
        self.screen_fade_menus[ str_menu_id ] = undefined;
        
        if ( !self.screen_fade_menus.size )
        {
            self.screen_fade_menus = undefined;
        }
    }
}
 
function private ‪_one_screen_fade_per_network_frame( s_menu )
{
    while ( s_menu.screen_fade_network_frame === level.network_frame )
    {
        ‪util::wait_network_frame();
    }
    
    s_menu.screen_fade_network_frame = level.network_frame;
}
 
function ‪open_generic_script_dialog( title, description )
{
    self endon( "disconnect" );
    
    dialog = self OpenLUIMenu( "ScriptMessageDialog_Compact" );
    self SetLUIMenuData( dialog, "title", title );
    self SetLUIMenuData( dialog, "description", description );
    
    do
    {
        self waittill( "menuresponse", menu, response );
    }
    while( menu != "ScriptMessageDialog_Compact" || response != "close" );
    
    self CloseLUIMenu( dialog );
}
 
function ‪open_script_dialog( dialog_name )
{
    self endon( "disconnect" );
    
    dialog = self OpenLUIMenu( dialog_name );
    
    do
    {
        self waittill( "menuresponse", menu, response );
    }
    while( menu != dialog_name || response != "close" );
    
    self CloseLUIMenu( dialog );
}