mirror of
https://github.com/JezuzLizard/Recompilable-gscs-for-BO2-zombies-and-multiplayer.git
synced 2025-06-09 10:27:51 -05:00
3274 lines
70 KiB
Plaintext
3274 lines
70 KiB
Plaintext
#include maps/mp/_script_gen;
|
|
#include maps/mp/_fx;
|
|
#include maps/mp/_createfxundo;
|
|
#include maps/mp/_createfxmenu;
|
|
#include maps/mp/_utility;
|
|
#include common_scripts/utility;
|
|
|
|
createfx()
|
|
{
|
|
/#
|
|
println( "^2Running CreateFX 2.0" );
|
|
#/
|
|
if ( ismp() )
|
|
{
|
|
init_mp_paths();
|
|
level.timelimitoverride = 1;
|
|
}
|
|
else
|
|
{
|
|
init_sp_paths();
|
|
}
|
|
precachemodel( "fx_axis_createfx" );
|
|
precacheshader( "black" );
|
|
if ( getDvar( "createfx_scaleid" ) == "" )
|
|
{
|
|
setdvar( "createfx_scaleid", "0.5" );
|
|
}
|
|
if ( getDvar( "createfx_print_frames" ) == "" )
|
|
{
|
|
setdvar( "createfx_print_frames", "3" );
|
|
}
|
|
if ( getDvar( "createfx_drawaxis" ) == "" )
|
|
{
|
|
setdvar( "createfx_drawaxis", "1" );
|
|
}
|
|
if ( getDvar( "createfx_drawaxis_range" ) == "" )
|
|
{
|
|
setdvar( "createfx_drawaxis_range", "2000" );
|
|
}
|
|
if ( getDvar( "createfx_autosave_time" ) == "" )
|
|
{
|
|
setdvar( "createfx_autosave_time", "300" );
|
|
}
|
|
if ( getDvar( "createfx_oneshot_min_delay" ) == "" )
|
|
{
|
|
setdvar( "createfx_oneshot_min_delay", "-100" );
|
|
}
|
|
if ( getDvar( "createfx_oneshot_max_delay" ) == "" )
|
|
{
|
|
setdvar( "createfx_oneshot_max_delay", "-15" );
|
|
}
|
|
flag_init( "createfx_saving" );
|
|
if ( !isDefined( level.createfx ) )
|
|
{
|
|
level.createfx = [];
|
|
}
|
|
if ( !isDefined( level.cfx_uniqueid ) )
|
|
{
|
|
level.cfx_uniqueid = 0;
|
|
}
|
|
level.cfx_last_action = "none";
|
|
if ( !ismp() )
|
|
{
|
|
level thread [[ level.cfx_func_run_gump_func ]]();
|
|
}
|
|
if ( isDefined( level.createfx_callback_thread ) )
|
|
{
|
|
level thread [[ level.createfx_callback_thread ]]();
|
|
}
|
|
if ( ismp() )
|
|
{
|
|
level.callbackplayerdisconnect = ::empty;
|
|
level.callbackplayerdamage = ::damage_void;
|
|
level.callbackplayerkilled = ::empty;
|
|
level.callbackplayerconnect = ::callback_playerconnect;
|
|
while ( !isDefined( level.player ) )
|
|
{
|
|
wait 0,05;
|
|
}
|
|
thread createfxdelay();
|
|
}
|
|
level.is_camera_on = 0;
|
|
thread createfxlogic();
|
|
level waittill( "eternity" );
|
|
}
|
|
|
|
fx_init()
|
|
{
|
|
if ( ismp() )
|
|
{
|
|
init_client_mp_variables();
|
|
}
|
|
else
|
|
{
|
|
init_client_sp_variables();
|
|
}
|
|
level.exploderfunction = level.cfx_exploder_before;
|
|
waittillframeend;
|
|
waittillframeend;
|
|
level.exploderfunction = level.cfx_exploder_after;
|
|
level.non_fx_ents = 0;
|
|
if ( level.createfx_enabled )
|
|
{
|
|
triggers = getentarray( "trigger_multiple", "classname" );
|
|
i = 0;
|
|
while ( i < triggers.size )
|
|
{
|
|
triggers[ i ] delete();
|
|
i++;
|
|
}
|
|
triggers = getentarray( "trigger_once", "classname" );
|
|
i = 0;
|
|
while ( i < triggers.size )
|
|
{
|
|
triggers[ i ] delete();
|
|
i++;
|
|
}
|
|
triggers = getentarray( "trigger_box", "classname" );
|
|
i = 0;
|
|
while ( i < triggers.size )
|
|
{
|
|
triggers[ i ] delete();
|
|
i++;
|
|
}
|
|
triggers = getentarray( "trigger_radius", "classname" );
|
|
i = 0;
|
|
while ( i < triggers.size )
|
|
{
|
|
triggers[ i ] delete();
|
|
i++;
|
|
}
|
|
triggers = getentarray( "trigger_lookat", "classname" );
|
|
i = 0;
|
|
while ( i < triggers.size )
|
|
{
|
|
triggers[ i ] delete();
|
|
i++;
|
|
}
|
|
triggers = getentarray( "trigger_damage", "classname" );
|
|
i = 0;
|
|
while ( i < triggers.size )
|
|
{
|
|
triggers[ i ] delete();
|
|
i++;
|
|
}
|
|
sm = getentarray( "spawn_manager", "classname" );
|
|
i = 0;
|
|
while ( i < sm.size )
|
|
{
|
|
sm[ i ] delete();
|
|
i++;
|
|
}
|
|
delete_spawns();
|
|
if ( !ismp() )
|
|
{
|
|
delete_arrays_in_sp();
|
|
/#
|
|
println( "We're not in MP!" );
|
|
#/
|
|
}
|
|
}
|
|
i = 0;
|
|
while ( i < level.createfxent.size )
|
|
{
|
|
ent = level.createfxent[ i ];
|
|
ent set_forward_and_up_vectors();
|
|
if ( level.clientscripts )
|
|
{
|
|
if ( !level.createfx_enabled )
|
|
{
|
|
i++;
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( isDefined( ent.model ) )
|
|
{
|
|
level.non_fx_ents++;
|
|
}
|
|
if ( ent.v[ "type" ] == "loopfx" )
|
|
{
|
|
ent thread [[ level.cfx_func_loopfx ]]();
|
|
}
|
|
if ( ent.v[ "type" ] == "oneshotfx" )
|
|
{
|
|
ent thread [[ level.cfx_func_oneshotfx ]]();
|
|
}
|
|
if ( ent.v[ "type" ] == "soundfx" )
|
|
{
|
|
ent thread [[ level.cfx_func_soundfx ]]();
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
|
|
add_effect( name, effect )
|
|
{
|
|
if ( !isDefined( level._effect ) )
|
|
{
|
|
level._effect = [];
|
|
}
|
|
level._effect[ name ] = loadfx( effect );
|
|
}
|
|
|
|
createeffect( type, fxid )
|
|
{
|
|
ent = undefined;
|
|
if ( !isDefined( level.createfx_enabled ) )
|
|
{
|
|
level.createfx_enabled = getDvar( "createfx" ) != "";
|
|
}
|
|
if ( !isDefined( level.createfxent ) )
|
|
{
|
|
level.createfxent = [];
|
|
}
|
|
if ( level.createfx_enabled )
|
|
{
|
|
if ( !isDefined( level.cfx_uniqueid ) )
|
|
{
|
|
level.cfx_uniqueid = 0;
|
|
}
|
|
ent = spawnstruct();
|
|
ent.uniqueid = level.cfx_uniqueid;
|
|
level.cfx_uniqueid++;
|
|
}
|
|
else if ( type == "exploder" )
|
|
{
|
|
ent = spawnstruct();
|
|
}
|
|
else
|
|
{
|
|
if ( !isDefined( level._fake_createfx_struct ) )
|
|
{
|
|
level._fake_createfx_struct = spawnstruct();
|
|
}
|
|
ent = level._fake_createfx_struct;
|
|
}
|
|
level.createfxent[ level.createfxent.size ] = ent;
|
|
ent.v = [];
|
|
ent.v[ "type" ] = type;
|
|
ent.v[ "fxid" ] = fxid;
|
|
ent.v[ "angles" ] = ( 1, 1, 1 );
|
|
ent.v[ "origin" ] = ( 1, 1, 1 );
|
|
ent.drawn = 1;
|
|
return ent;
|
|
}
|
|
|
|
createloopsound()
|
|
{
|
|
ent = spawnstruct();
|
|
if ( !isDefined( level.createfxent ) )
|
|
{
|
|
level.createfxent = [];
|
|
}
|
|
level.createfxent[ level.createfxent.size ] = ent;
|
|
ent.v = [];
|
|
ent.v[ "type" ] = "soundfx";
|
|
ent.v[ "fxid" ] = "No FX";
|
|
ent.v[ "soundalias" ] = "nil";
|
|
ent.v[ "angles" ] = ( 1, 1, 1 );
|
|
ent.v[ "origin" ] = ( 1, 1, 1 );
|
|
ent.drawn = 1;
|
|
return ent;
|
|
}
|
|
|
|
set_forward_and_up_vectors()
|
|
{
|
|
self.v[ "up" ] = anglesToUp( self.v[ "angles" ] );
|
|
self.v[ "forward" ] = anglesToForward( self.v[ "angles" ] );
|
|
}
|
|
|
|
createfxlogic()
|
|
{
|
|
waittillframeend;
|
|
menu_init();
|
|
if ( !ismp() )
|
|
{
|
|
players = get_players();
|
|
if ( !isDefined( players ) || players.size == 0 )
|
|
{
|
|
level waittill( "first_player_ready" );
|
|
}
|
|
}
|
|
/#
|
|
adddebugcommand( "noclip" );
|
|
#/
|
|
if ( !isDefined( level._effect ) )
|
|
{
|
|
level._effect = [];
|
|
}
|
|
if ( getDvar( "createfx_map" ) == "" )
|
|
{
|
|
setdvar( "createfx_map", level.script );
|
|
}
|
|
else
|
|
{
|
|
if ( getDvar( "createfx_map" ) == level.script )
|
|
{
|
|
if ( !ismp() )
|
|
{
|
|
playerpos = [];
|
|
playerpos[ 0 ] = getDvarInt( #"274F266C" );
|
|
playerpos[ 1 ] = getDvarInt( #"274F266D" );
|
|
playerpos[ 2 ] = getDvarInt( #"274F266E" );
|
|
player = get_players()[ 0 ];
|
|
player setorigin( ( playerpos[ 0 ], playerpos[ 1 ], playerpos[ 2 ] ) );
|
|
}
|
|
}
|
|
}
|
|
/#
|
|
filename = level.cfx_server_scriptdata + level.script + "_fx.gsc";
|
|
file = openfile( filename, "append" );
|
|
level.write_error = "";
|
|
if ( file == -1 )
|
|
{
|
|
level.write_error = filename;
|
|
}
|
|
else
|
|
{
|
|
closefile( file );
|
|
#/
|
|
}
|
|
level.createfxhudelements = [];
|
|
level.createfx_hudelements = 100;
|
|
stroffsetx = [];
|
|
stroffsety = [];
|
|
stroffsetx[ 0 ] = 0;
|
|
stroffsety[ 0 ] = 0;
|
|
stroffsetx[ 1 ] = 1;
|
|
stroffsety[ 1 ] = 1;
|
|
stroffsetx[ 2 ] = -2;
|
|
stroffsety[ 2 ] = 1;
|
|
setdvar( "fx", "nil" );
|
|
crosshair = newdebughudelem();
|
|
crosshair.location = 0;
|
|
crosshair.alignx = "center";
|
|
crosshair.aligny = "middle";
|
|
crosshair.foreground = 1;
|
|
crosshair.fontscale = 2;
|
|
crosshair.sort = 20;
|
|
crosshair.alpha = 1;
|
|
crosshair.x = 320;
|
|
crosshair.y = 233;
|
|
crosshair settext( "." );
|
|
center_text_init();
|
|
level.cleartextmarker = newdebughudelem();
|
|
level.cleartextmarker.alpha = 0;
|
|
level.cleartextmarker settext( "marker" );
|
|
i = 0;
|
|
while ( i < level.createfx_hudelements )
|
|
{
|
|
newstrarray = [];
|
|
p = 0;
|
|
while ( p < 2 )
|
|
{
|
|
newstr = newhudelem();
|
|
newstr.alignx = "left";
|
|
newstr.location = 0;
|
|
newstr.foreground = 1;
|
|
newstr.fontscale = 1,1;
|
|
newstr.sort = 20 - p;
|
|
newstr.alpha = 1;
|
|
newstr.x = 0 + stroffsetx[ p ];
|
|
newstr.y = ( 60 + stroffsety[ p ] ) + ( i * 15 );
|
|
if ( p > 0 )
|
|
{
|
|
newstr.color = ( 1, 1, 1 );
|
|
}
|
|
newstrarray[ newstrarray.size ] = newstr;
|
|
p++;
|
|
}
|
|
level.createfxhudelements[ i ] = newstrarray;
|
|
i++;
|
|
}
|
|
level.selectedmove_up = 0;
|
|
level.selectedmove_forward = 0;
|
|
level.selectedmove_right = 0;
|
|
level.selectedrotate_pitch = 0;
|
|
level.selectedrotate_roll = 0;
|
|
level.selectedrotate_yaw = 0;
|
|
level.selected_fx = [];
|
|
level.selected_fx_ents = [];
|
|
level.createfx_lockedlist = [];
|
|
level.createfx_lockedlist[ "escape" ] = 1;
|
|
level.createfx_lockedlist[ "BUTTON_LSHLDR" ] = 1;
|
|
level.createfx_lockedlist[ "BUTTON_RSHLDR" ] = 1;
|
|
level.createfx_lockedlist[ "mouse1" ] = 1;
|
|
level.createfx_lockedlist[ "ctrl" ] = 1;
|
|
level.createfx_draw_enabled = 1;
|
|
level.buttonisheld = [];
|
|
axismode = 0;
|
|
colors = [];
|
|
colors[ "loopfx" ][ "selected" ] = ( 1, 1, 0,2 );
|
|
colors[ "loopfx" ][ "highlighted" ] = ( 0,4, 0,95, 1 );
|
|
colors[ "loopfx" ][ "default" ] = ( 0,3, 0,5, 1 );
|
|
colors[ "oneshotfx" ][ "selected" ] = ( 1, 1, 0,2 );
|
|
colors[ "oneshotfx" ][ "highlighted" ] = ( 0,33, 0,97, 1 );
|
|
colors[ "oneshotfx" ][ "default" ] = ( 0,1, 0,73, 0,73 );
|
|
colors[ "exploder" ][ "selected" ] = ( 1, 1, 0,2 );
|
|
colors[ "exploder" ][ "highlighted" ] = ( 1, 0,1, 0,1 );
|
|
colors[ "exploder" ][ "default" ] = ( 1, 0,1, 0,1 );
|
|
colors[ "rainfx" ][ "selected" ] = ( 1, 1, 0,2 );
|
|
colors[ "rainfx" ][ "highlighted" ] = ( 0,95, 0,4, 0,95 );
|
|
colors[ "rainfx" ][ "default" ] = ( 0,78, 0, 0,73 );
|
|
colors[ "soundfx" ][ "selected" ] = ( 1, 1, 0,2 );
|
|
colors[ "soundfx" ][ "highlighted" ] = ( 0,5, 1, 0,75 );
|
|
colors[ "soundfx" ][ "default" ] = ( 0,2, 0,9, 0,2 );
|
|
lasthighlightedent = undefined;
|
|
level.fx_rotating = 0;
|
|
setmenu( "none" );
|
|
level.createfx_selecting = 0;
|
|
level.createfx_last_player_origin = ( 1, 1, 1 );
|
|
level.createfx_last_player_forward = ( 1, 1, 1 );
|
|
level.createfx_last_view_change_test = 0;
|
|
player = get_players()[ 0 ];
|
|
black = newdebughudelem();
|
|
black.x = -120;
|
|
black.y = 200;
|
|
black.foreground = 0;
|
|
black setshader( "black", 250, 160 );
|
|
black.alpha = 0;
|
|
level.createfx_inputlocked = 0;
|
|
help_on_last_frame = 0;
|
|
i = 0;
|
|
while ( i < level.createfxent.size )
|
|
{
|
|
ent = level.createfxent[ i ];
|
|
ent post_entity_creation_function();
|
|
i++;
|
|
}
|
|
thread draw_distance();
|
|
lastselectentity = undefined;
|
|
thread createfx_autosave();
|
|
if ( !ismp() )
|
|
{
|
|
make_sp_player_invulnerable( player );
|
|
}
|
|
for ( ;; )
|
|
{
|
|
player = get_players()[ 0 ];
|
|
changedselectedents = 0;
|
|
right = anglesToRight( player getplayerangles() );
|
|
forward = anglesToForward( player getplayerangles() );
|
|
up = anglesToUp( player getplayerangles() );
|
|
dot = 0,85;
|
|
placeent_vector = vectorScale( forward, 750 );
|
|
level.createfxcursor = bullettrace( player geteye(), player geteye() + placeent_vector, 0, undefined );
|
|
highlightedent = undefined;
|
|
level.buttonclick = [];
|
|
level.button_is_kb = [];
|
|
process_button_held_and_clicked();
|
|
ctrlheld = button_is_held( "ctrl", "BUTTON_LSHLDR" );
|
|
shiftheld = button_is_held( "shift" );
|
|
functionheld = button_is_held( "f" );
|
|
leftclick = button_is_clicked( "mouse1", "BUTTON_A" );
|
|
leftheld = button_is_held( "mouse1", "BUTTON_A" );
|
|
create_fx_menu();
|
|
if ( button_is_clicked( "BUTTON_X" ) || shiftheld && button_is_clicked( "x" ) )
|
|
{
|
|
axismode = !axismode;
|
|
}
|
|
if ( button_is_clicked( "F2" ) || functionheld && button_is_clicked( "2" ) )
|
|
{
|
|
toggle_createfx_drawing();
|
|
}
|
|
if ( button_is_clicked( "F3" ) || functionheld && button_is_clicked( "3" ) )
|
|
{
|
|
print_ambient_fx_inventory();
|
|
}
|
|
if ( button_is_clicked( "F5" ) || functionheld && button_is_clicked( "5" ) )
|
|
{
|
|
createfx_save();
|
|
}
|
|
if ( button_is_clicked( "ins", "i" ) )
|
|
{
|
|
insert_effect();
|
|
}
|
|
if ( button_is_clicked( "c" ) )
|
|
{
|
|
if ( level.is_camera_on == 0 )
|
|
{
|
|
/#
|
|
adddebugcommand( "noclip" );
|
|
#/
|
|
level thread handle_camera();
|
|
level.is_camera_on = 1;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if ( level.is_camera_on == 1 )
|
|
{
|
|
/#
|
|
adddebugcommand( "noclip" );
|
|
#/
|
|
level notify( "new_camera" );
|
|
level.is_camera_on = 0;
|
|
axismode = 0;
|
|
}
|
|
}
|
|
}
|
|
if ( button_is_held( "BUTTON_RTRIG" ) && level.is_camera_on )
|
|
{
|
|
axismode = 1;
|
|
}
|
|
else
|
|
{
|
|
if ( !button_is_held( "BUTTON_RTRIG" ) && level.is_camera_on )
|
|
{
|
|
axismode = 0;
|
|
}
|
|
}
|
|
if ( button_is_clicked( "del" ) || !shiftheld && button_is_clicked( "d" ) )
|
|
{
|
|
delete_pressed();
|
|
}
|
|
if ( button_is_clicked( "end" ) || shiftheld && button_is_clicked( "d" ) )
|
|
{
|
|
drop_selection_to_ground();
|
|
changedselectedents = 1;
|
|
}
|
|
if ( button_is_clicked( "s" ) )
|
|
{
|
|
setmenu( "select_by_property" );
|
|
wait 0,05;
|
|
}
|
|
if ( isDefined( level.cfx_selected_prop ) )
|
|
{
|
|
if ( ctrlheld )
|
|
{
|
|
select_ents_by_property( level.cfx_selected_prop, 1 );
|
|
}
|
|
else
|
|
{
|
|
select_ents_by_property( level.cfx_selected_prop );
|
|
}
|
|
level.cfx_selected_prop = undefined;
|
|
}
|
|
if ( button_is_clicked( "j" ) )
|
|
{
|
|
setmenu( "jump_to_effect" );
|
|
draw_effects_list( "Select effect to jump to:" );
|
|
}
|
|
if ( button_is_clicked( "escape" ) )
|
|
{
|
|
clear_settable_fx();
|
|
}
|
|
if ( button_is_clicked( "space" ) && !shiftheld )
|
|
{
|
|
set_off_exploders();
|
|
}
|
|
if ( button_is_clicked( "space" ) && shiftheld )
|
|
{
|
|
turn_off_exploders();
|
|
}
|
|
if ( button_is_clicked( "tab", "BUTTON_RSHLDR" ) )
|
|
{
|
|
move_selection_to_cursor();
|
|
changedselectedents = 1;
|
|
}
|
|
if ( button_is_clicked( "z" ) )
|
|
{
|
|
if ( shiftheld )
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
undo();
|
|
}
|
|
}
|
|
if ( button_is_held( "q", "F1" ) )
|
|
{
|
|
help_on_last_frame = 1;
|
|
show_help();
|
|
wait 0,05;
|
|
continue;
|
|
}
|
|
else if ( help_on_last_frame == 1 )
|
|
{
|
|
clear_fx_hudelements();
|
|
help_on_last_frame = 0;
|
|
}
|
|
if ( button_is_clicked( "BUTTON_LSTICK" ) && !ctrlheld )
|
|
{
|
|
copy_ents();
|
|
}
|
|
if ( button_is_clicked( "BUTTON_RSTICK" ) )
|
|
{
|
|
if ( ctrlheld )
|
|
{
|
|
paste_ents_onto_ents();
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
paste_ents();
|
|
}
|
|
}
|
|
if ( isDefined( level.selected_fx_option_index ) )
|
|
{
|
|
menu_fx_option_set();
|
|
}
|
|
if ( button_is_held( "BUTTON_RTRIG" ) && button_is_held( "BUTTON_LTRIG" ) )
|
|
{
|
|
move_player_around_map_fast();
|
|
wait 0,25;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
if ( menu( "none" ) )
|
|
{
|
|
if ( button_is_clicked( "rightarrow" ) )
|
|
{
|
|
move_player_to_next_same_effect( 1, lastselectentity );
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if ( button_is_clicked( "leftarrow" ) )
|
|
{
|
|
move_player_to_next_same_effect( 0, lastselectentity );
|
|
}
|
|
}
|
|
}
|
|
if ( level.write_error != "" )
|
|
{
|
|
level notify( "write_error" );
|
|
thread write_error_msg( level.write_error );
|
|
level.write_error = "";
|
|
}
|
|
highlightedent = level.fx_highlightedent;
|
|
if ( leftclick || ( getTime() - level.createfx_last_view_change_test ) > 250 )
|
|
{
|
|
if ( !leftclick || vector_changed( level.createfx_last_player_origin, player.origin ) && dot_changed( level.createfx_last_player_forward, forward ) )
|
|
{
|
|
i = 0;
|
|
while ( i < level.createfxent.size )
|
|
{
|
|
ent = level.createfxent[ i ];
|
|
if ( !ent.drawn )
|
|
{
|
|
i++;
|
|
continue;
|
|
}
|
|
else difference = vectornormalize( ent.v[ "origin" ] - ( player.origin + vectorScale( ( 1, 1, 1 ), 55 ) ) );
|
|
newdot = vectordot( forward, difference );
|
|
if ( newdot < dot )
|
|
{
|
|
i++;
|
|
continue;
|
|
}
|
|
else if ( newdot == dot )
|
|
{
|
|
if ( ent_is_selected( ent ) )
|
|
{
|
|
i++;
|
|
continue;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
dot = newdot;
|
|
highlightedent = ent;
|
|
highlightedent.last_fx_index = i;
|
|
}
|
|
i++;
|
|
}
|
|
level.fx_highlightedent = highlightedent;
|
|
level.createfx_last_player_origin = player.origin;
|
|
level.createfx_last_player_forward = forward;
|
|
}
|
|
level.createfx_last_view_change_test = getTime();
|
|
}
|
|
if ( isDefined( highlightedent ) )
|
|
{
|
|
if ( isDefined( lasthighlightedent ) )
|
|
{
|
|
if ( lasthighlightedent != highlightedent )
|
|
{
|
|
if ( !ent_is_selected( lasthighlightedent ) )
|
|
{
|
|
lasthighlightedent thread entity_highlight_disable();
|
|
}
|
|
if ( !ent_is_selected( highlightedent ) )
|
|
{
|
|
highlightedent thread entity_highlight_enable();
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if ( !ent_is_selected( highlightedent ) )
|
|
{
|
|
highlightedent thread entity_highlight_enable();
|
|
}
|
|
}
|
|
}
|
|
manipulate_createfx_ents( highlightedent, leftclick, leftheld, ctrlheld, colors, right );
|
|
if ( axismode && level.selected_fx_ents.size > 0 )
|
|
{
|
|
thread process_fx_rotater();
|
|
if ( button_is_clicked( "enter", "r" ) )
|
|
{
|
|
reset_axis_of_selected_ents();
|
|
}
|
|
if ( button_is_clicked( "v" ) )
|
|
{
|
|
copy_angles_of_selected_ents();
|
|
}
|
|
while ( getDvarInt( "createfx_drawaxis" ) == 1 )
|
|
{
|
|
i = 0;
|
|
while ( i < level.selected_fx_ents.size )
|
|
{
|
|
level.selected_fx_ents[ i ] draw_axis();
|
|
i++;
|
|
}
|
|
}
|
|
if ( level.selectedrotate_pitch != 0 || level.selectedrotate_yaw != 0 && level.selectedrotate_roll != 0 )
|
|
{
|
|
changedselectedents = 1;
|
|
}
|
|
wait 0,05;
|
|
}
|
|
else
|
|
{
|
|
stop_drawing_axis_models();
|
|
selectedmove_vector = get_selected_move_vector();
|
|
if ( distancesquared( ( 1, 1, 1 ), selectedmove_vector ) > 0 )
|
|
{
|
|
changedselectedents = 1;
|
|
if ( level.cfx_last_action != "translate" )
|
|
{
|
|
store_undo_state( "edit", level.selected_fx_ents );
|
|
level.cfx_last_action = "translate";
|
|
}
|
|
}
|
|
i = 0;
|
|
while ( i < level.selected_fx_ents.size )
|
|
{
|
|
ent = level.selected_fx_ents[ i ];
|
|
if ( isDefined( ent.model ) )
|
|
{
|
|
i++;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
ent.v[ "origin" ] += selectedmove_vector;
|
|
}
|
|
i++;
|
|
}
|
|
wait 0,05;
|
|
}
|
|
if ( changedselectedents )
|
|
{
|
|
update_selected_entities();
|
|
}
|
|
lasthighlightedent = highlightedent;
|
|
if ( last_selected_entity_has_changed( lastselectentity ) )
|
|
{
|
|
level.effect_list_offset = 0;
|
|
clear_settable_fx();
|
|
setmenu( "none" );
|
|
}
|
|
if ( level.selected_fx_ents.size )
|
|
{
|
|
lastselectentity = level.selected_fx_ents[ level.selected_fx_ents.size - 1 ];
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
lastselectentity = undefined;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
toggle_createfx_drawing()
|
|
{
|
|
level.createfx_draw_enabled = !level.createfx_draw_enabled;
|
|
}
|
|
|
|
manipulate_createfx_ents( highlightedent, leftclick, leftheld, ctrlheld, colors, right )
|
|
{
|
|
if ( !level.createfx_draw_enabled )
|
|
{
|
|
clear_fx_hudelements();
|
|
return;
|
|
}
|
|
scale = getDvarFloat( "createfx_scaleid" );
|
|
print_frames = getDvarInt( "createfx_print_frames" );
|
|
if ( !isDefined( level.createfx_manipulate_offset ) )
|
|
{
|
|
level.createfx_manipulate_offset = 0;
|
|
}
|
|
offset = level.createfx_manipulate_offset;
|
|
level.createfx_manipulate_offset = ( level.createfx_manipulate_offset + 1 ) % print_frames;
|
|
i = offset;
|
|
while ( i < level.createfxent.size )
|
|
{
|
|
ent = level.createfxent[ i ];
|
|
if ( !ent.drawn )
|
|
{
|
|
}
|
|
else if ( isDefined( highlightedent ) && ent == highlightedent )
|
|
{
|
|
}
|
|
else colorindex = "default";
|
|
if ( index_is_selected( i ) )
|
|
{
|
|
colorindex = "selected";
|
|
}
|
|
/#
|
|
print3d( ent.v[ "origin" ], ".", colors[ ent.v[ "type" ] ][ colorindex ], 1, scale, print_frames );
|
|
#/
|
|
if ( ent.textalpha > 0 )
|
|
{
|
|
printright = vectorScale( right, ( ent.v[ "fxid" ].size * -2,93 ) * scale );
|
|
printup = ( 0, 0, 15 * scale );
|
|
/#
|
|
print3d( ent.v[ "origin" ] + printright + printup, ent.v[ "fxid" ], colors[ ent.v[ "type" ] ][ colorindex ], ent.textalpha, scale, print_frames );
|
|
#/
|
|
}
|
|
i += print_frames;
|
|
}
|
|
if ( isDefined( highlightedent ) )
|
|
{
|
|
if ( !entities_are_selected() )
|
|
{
|
|
display_fx_info( highlightedent );
|
|
}
|
|
if ( leftclick )
|
|
{
|
|
entwasselected = index_is_selected( highlightedent.last_fx_index );
|
|
level.createfx_selecting = !entwasselected;
|
|
if ( !ctrlheld )
|
|
{
|
|
selectedsize = level.selected_fx_ents.size;
|
|
clear_entity_selection();
|
|
if ( entwasselected && selectedsize == 1 )
|
|
{
|
|
select_entity( highlightedent.last_fx_index, highlightedent );
|
|
}
|
|
}
|
|
toggle_entity_selection( highlightedent.last_fx_index, highlightedent );
|
|
}
|
|
else
|
|
{
|
|
if ( leftheld )
|
|
{
|
|
if ( ctrlheld )
|
|
{
|
|
if ( level.createfx_selecting )
|
|
{
|
|
select_entity( highlightedent.last_fx_index, highlightedent );
|
|
}
|
|
if ( !level.createfx_selecting )
|
|
{
|
|
deselect_entity( highlightedent.last_fx_index, highlightedent );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
colorindex = "highlighted";
|
|
if ( index_is_selected( highlightedent.last_fx_index ) )
|
|
{
|
|
colorindex = "selected";
|
|
}
|
|
/#
|
|
print3d( highlightedent.v[ "origin" ], ".", colors[ highlightedent.v[ "type" ] ][ colorindex ], 1, scale, 1 );
|
|
#/
|
|
if ( highlightedent.textalpha > 0 )
|
|
{
|
|
printright = vectorScale( right, ( highlightedent.v[ "fxid" ].size * -2,93 ) * scale );
|
|
printup = ( 0, 0, 15 * scale );
|
|
/#
|
|
print3d( highlightedent.v[ "origin" ] + printright + printup, highlightedent.v[ "fxid" ], colors[ highlightedent.v[ "type" ] ][ colorindex ], highlightedent.textalpha, scale, 1 );
|
|
#/
|
|
}
|
|
}
|
|
}
|
|
|
|
clear_settable_fx()
|
|
{
|
|
level.createfx_inputlocked = 0;
|
|
setdvar( "fx", "nil" );
|
|
level.selected_fx_option_index = undefined;
|
|
reset_fx_hud_colors();
|
|
}
|
|
|
|
reset_fx_hud_colors()
|
|
{
|
|
i = 0;
|
|
while ( i < level.createfx_hudelements )
|
|
{
|
|
level.createfxhudelements[ i ][ 0 ].color = ( 1, 1, 1 );
|
|
i++;
|
|
}
|
|
}
|
|
|
|
button_is_held( name, name2 )
|
|
{
|
|
if ( isDefined( name2 ) )
|
|
{
|
|
if ( isDefined( level.buttonisheld[ name2 ] ) )
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
return isDefined( level.buttonisheld[ name ] );
|
|
}
|
|
|
|
button_is_clicked( name, name2 )
|
|
{
|
|
if ( isDefined( name2 ) )
|
|
{
|
|
if ( isDefined( level.buttonclick[ name2 ] ) )
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
return isDefined( level.buttonclick[ name ] );
|
|
}
|
|
|
|
toggle_entity_selection( index, ent )
|
|
{
|
|
if ( isDefined( level.selected_fx[ index ] ) )
|
|
{
|
|
deselect_entity( index, ent );
|
|
}
|
|
else
|
|
{
|
|
select_entity( index, ent );
|
|
}
|
|
}
|
|
|
|
select_entity( index, ent, skip_undo )
|
|
{
|
|
if ( isDefined( level.selected_fx[ index ] ) )
|
|
{
|
|
return;
|
|
}
|
|
ent.last_fx_index = index;
|
|
if ( !isDefined( skip_undo ) && level.cfx_last_action != "none" )
|
|
{
|
|
store_undo_state( "edit", level.selected_fx_ents );
|
|
level.cfx_last_action = "none";
|
|
}
|
|
clear_settable_fx();
|
|
level notify( "new_ent_selection" );
|
|
ent thread entity_highlight_enable();
|
|
level.selected_fx[ index ] = 1;
|
|
level.selected_fx_ents[ level.selected_fx_ents.size ] = ent;
|
|
}
|
|
|
|
ent_is_highlighted( ent )
|
|
{
|
|
if ( !isDefined( level.fx_highlightedent ) )
|
|
{
|
|
return 0;
|
|
}
|
|
return ent == level.fx_highlightedent;
|
|
}
|
|
|
|
deselect_entity( index, ent )
|
|
{
|
|
if ( !isDefined( level.selected_fx[ index ] ) )
|
|
{
|
|
return;
|
|
}
|
|
if ( level.cfx_last_action != "none" )
|
|
{
|
|
store_undo_state( "edit", level.selected_fx_ents );
|
|
level.cfx_last_action = "none";
|
|
}
|
|
clear_settable_fx();
|
|
level notify( "new_ent_selection" );
|
|
if ( !ent_is_highlighted( ent ) )
|
|
{
|
|
ent thread entity_highlight_disable();
|
|
}
|
|
newarray = [];
|
|
i = 0;
|
|
while ( i < level.selected_fx_ents.size )
|
|
{
|
|
if ( level.selected_fx_ents[ i ] != ent )
|
|
{
|
|
newarray[ newarray.size ] = level.selected_fx_ents[ i ];
|
|
}
|
|
i++;
|
|
}
|
|
level.selected_fx_ents = newarray;
|
|
}
|
|
|
|
index_is_selected( index )
|
|
{
|
|
return isDefined( level.selected_fx[ index ] );
|
|
}
|
|
|
|
ent_is_selected( ent )
|
|
{
|
|
i = 0;
|
|
while ( i < level.selected_fx_ents.size )
|
|
{
|
|
if ( level.selected_fx_ents[ i ] == ent )
|
|
{
|
|
return 1;
|
|
}
|
|
i++;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
clear_entity_selection( skip_undo )
|
|
{
|
|
if ( !isDefined( skip_undo ) && level.cfx_last_action != "none" )
|
|
{
|
|
store_undo_state( "edit", level.selected_fx_ents );
|
|
level.cfx_last_action = "none";
|
|
}
|
|
i = 0;
|
|
while ( i < level.selected_fx_ents.size )
|
|
{
|
|
if ( !ent_is_highlighted( level.selected_fx_ents[ i ] ) )
|
|
{
|
|
level.selected_fx_ents[ i ] thread entity_highlight_disable();
|
|
}
|
|
i++;
|
|
}
|
|
level.selected_fx = [];
|
|
level.selected_fx_ents = [];
|
|
}
|
|
|
|
draw_axis()
|
|
{
|
|
if ( isDefined( self.draw_axis_model ) )
|
|
{
|
|
return;
|
|
}
|
|
self.draw_axis_model = spawn_axis_model( self.v[ "origin" ], self.v[ "angles" ] );
|
|
level thread draw_axis_think( self );
|
|
if ( !isDefined( level.draw_axis_models ) )
|
|
{
|
|
level.draw_axis_models = [];
|
|
}
|
|
level.draw_axis_models[ level.draw_axis_models.size ] = self.draw_axis_model;
|
|
}
|
|
|
|
spawn_axis_model( origin, angles )
|
|
{
|
|
model = spawn( "script_model", origin );
|
|
model setmodel( "fx_axis_createfx" );
|
|
model.angles = angles;
|
|
return model;
|
|
}
|
|
|
|
draw_axis_think( axis_parent )
|
|
{
|
|
axis_model = axis_parent.draw_axis_model;
|
|
axis_model endon( "death" );
|
|
player = get_players()[ 0 ];
|
|
range = getDvarInt( "createfx_drawaxis_range" );
|
|
i = 0;
|
|
while ( 1 )
|
|
{
|
|
if ( !isDefined( axis_parent ) )
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
if ( distancesquared( axis_model.origin, player.origin ) > ( range * range ) )
|
|
{
|
|
if ( isDefined( axis_model ) )
|
|
{
|
|
axis_model delete();
|
|
arrayremovevalue( level.draw_axis_models, undefined );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( !isDefined( axis_model ) )
|
|
{
|
|
axis_model = spawn_axis_model( axis_parent.v[ "origin" ], axis_parent.v[ "angles" ] );
|
|
axis_parent.draw_axis_model = axis_model;
|
|
level.draw_axis_models[ level.draw_axis_models.size ] = axis_model;
|
|
}
|
|
}
|
|
axis_model.origin = axis_parent.v[ "origin" ];
|
|
axis_model.angles = axis_parent.v[ "angles" ];
|
|
wait 0,1;
|
|
i++;
|
|
if ( i >= 10 )
|
|
{
|
|
range = getDvarInt( "createfx_drawaxis_range" );
|
|
i = 0;
|
|
}
|
|
}
|
|
}
|
|
if ( isDefined( axis_model ) )
|
|
{
|
|
axis_model delete();
|
|
}
|
|
}
|
|
|
|
stop_drawing_axis_models()
|
|
{
|
|
if ( isDefined( level.draw_axis_models ) )
|
|
{
|
|
i = 0;
|
|
while ( i < level.draw_axis_models.size )
|
|
{
|
|
if ( isDefined( level.draw_axis_models[ i ] ) )
|
|
{
|
|
level.draw_axis_models[ i ] delete();
|
|
}
|
|
i++;
|
|
}
|
|
arrayremovevalue( level.draw_axis_models, undefined );
|
|
}
|
|
}
|
|
|
|
clear_fx_hudelements()
|
|
{
|
|
level.cfx_center_text[ level.cfx_center_text_max - 1 ] clearalltextafterhudelem();
|
|
i = 0;
|
|
while ( i < level.createfx_hudelements )
|
|
{
|
|
p = 0;
|
|
while ( p < 2 )
|
|
{
|
|
level.createfxhudelements[ i ][ p ] settext( "" );
|
|
p++;
|
|
}
|
|
i++;
|
|
}
|
|
level.fxhudelements = 0;
|
|
}
|
|
|
|
set_fx_hudelement( text )
|
|
{
|
|
if ( ismp() && !isDefined( level.createfx_delay_done ) )
|
|
{
|
|
return;
|
|
}
|
|
if ( level.fxhudelements < level.createfx_hudelements )
|
|
{
|
|
p = 0;
|
|
while ( p < 2 )
|
|
{
|
|
level.createfxhudelements[ level.fxhudelements ][ p ] settext( text );
|
|
p++;
|
|
}
|
|
level.fxhudelements++;
|
|
}
|
|
}
|
|
|
|
buttondown( button, button2 )
|
|
{
|
|
if ( !buttonpressed_internal( button ) )
|
|
{
|
|
return buttonpressed_internal( button2 );
|
|
}
|
|
}
|
|
|
|
buttonpressed_internal( button )
|
|
{
|
|
if ( !isDefined( button ) )
|
|
{
|
|
return 0;
|
|
}
|
|
if ( kb_locked( button ) )
|
|
{
|
|
return 0;
|
|
}
|
|
player = get_players()[ 0 ];
|
|
return player buttonpressed( button );
|
|
}
|
|
|
|
get_selected_move_vector()
|
|
{
|
|
player = get_players()[ 0 ];
|
|
yaw = player getplayerangles()[ 1 ];
|
|
angles = ( 0, yaw, 0 );
|
|
right = anglesToRight( angles );
|
|
forward = anglesToForward( angles );
|
|
up = anglesToUp( angles );
|
|
ctrlheld = button_is_held( "ctrl", "BUTTON_LSHLDR" );
|
|
if ( buttondown( "kp_uparrow", "DPAD_UP" ) )
|
|
{
|
|
if ( level.selectedmove_forward < 0 )
|
|
{
|
|
level.selectedmove_forward = 0;
|
|
}
|
|
if ( ctrlheld )
|
|
{
|
|
level.selectedmove_forward = 0,1;
|
|
wait 0,05;
|
|
}
|
|
else
|
|
{
|
|
level.selectedmove_forward += 1;
|
|
}
|
|
}
|
|
else if ( buttondown( "kp_downarrow", "DPAD_DOWN" ) )
|
|
{
|
|
if ( level.selectedmove_forward > 0 )
|
|
{
|
|
level.selectedmove_forward = 0;
|
|
}
|
|
if ( ctrlheld )
|
|
{
|
|
level.selectedmove_forward = -1 * 0,1;
|
|
wait 0,05;
|
|
}
|
|
else
|
|
{
|
|
level.selectedmove_forward -= 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
level.selectedmove_forward = 0;
|
|
}
|
|
if ( buttondown( "kp_rightarrow", "DPAD_RIGHT" ) )
|
|
{
|
|
if ( level.selectedmove_right < 0 )
|
|
{
|
|
level.selectedmove_right = 0;
|
|
}
|
|
if ( ctrlheld )
|
|
{
|
|
level.selectedmove_right = 0,1;
|
|
wait 0,05;
|
|
}
|
|
else
|
|
{
|
|
level.selectedmove_right += 1;
|
|
}
|
|
}
|
|
else if ( buttondown( "kp_leftarrow", "DPAD_LEFT" ) )
|
|
{
|
|
if ( level.selectedmove_right > 0 )
|
|
{
|
|
level.selectedmove_right = 0;
|
|
}
|
|
if ( ctrlheld )
|
|
{
|
|
level.selectedmove_right = -1 * 0,1;
|
|
wait 0,05;
|
|
}
|
|
else
|
|
{
|
|
level.selectedmove_right -= 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
level.selectedmove_right = 0;
|
|
}
|
|
if ( buttondown( "BUTTON_Y" ) )
|
|
{
|
|
if ( level.selectedmove_up < 0 )
|
|
{
|
|
level.selectedmove_up = 0;
|
|
}
|
|
if ( ctrlheld )
|
|
{
|
|
level.selectedmove_up = 0,1;
|
|
wait 0,05;
|
|
}
|
|
else
|
|
{
|
|
level.selectedmove_up += 1;
|
|
}
|
|
}
|
|
else if ( buttondown( "BUTTON_B" ) )
|
|
{
|
|
if ( level.selectedmove_up > 0 )
|
|
{
|
|
level.selectedmove_up = 0;
|
|
}
|
|
if ( ctrlheld )
|
|
{
|
|
level.selectedmove_up = -1 * 0,1;
|
|
wait 0,05;
|
|
}
|
|
else
|
|
{
|
|
level.selectedmove_up -= 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
level.selectedmove_up = 0;
|
|
}
|
|
vector = ( 1, 1, 1 );
|
|
vector += vectorScale( forward, level.selectedmove_forward );
|
|
vector += vectorScale( right, level.selectedmove_right );
|
|
vector += vectorScale( up, level.selectedmove_up );
|
|
return vector;
|
|
}
|
|
|
|
process_button_held_and_clicked()
|
|
{
|
|
add_button( "mouse1" );
|
|
add_kb_button( "shift" );
|
|
add_kb_button( "ctrl" );
|
|
add_button( "BUTTON_RSHLDR" );
|
|
add_button( "BUTTON_LSHLDR" );
|
|
add_button( "BUTTON_RSTICK" );
|
|
add_button( "BUTTON_LSTICK" );
|
|
add_button( "BUTTON_A" );
|
|
add_button( "BUTTON_B" );
|
|
add_button( "BUTTON_X" );
|
|
add_button( "BUTTON_Y" );
|
|
add_button( "DPAD_UP" );
|
|
add_button( "DPAD_LEFT" );
|
|
add_button( "DPAD_RIGHT" );
|
|
add_button( "DPAD_DOWN" );
|
|
add_kb_button( "escape" );
|
|
add_button( "BUTTON_RTRIG" );
|
|
add_button( "BUTTON_LTRIG" );
|
|
add_kb_button( "a" );
|
|
add_button( "F1" );
|
|
add_button( "F5" );
|
|
add_button( "F2" );
|
|
add_kb_button( "c" );
|
|
add_kb_button( "d" );
|
|
add_kb_button( "f" );
|
|
add_kb_button( "h" );
|
|
add_kb_button( "i" );
|
|
add_kb_button( "j" );
|
|
add_kb_button( "k" );
|
|
add_kb_button( "l" );
|
|
add_kb_button( "m" );
|
|
add_kb_button( "p" );
|
|
add_kb_button( "q" );
|
|
add_kb_button( "r" );
|
|
add_kb_button( "s" );
|
|
add_kb_button( "v" );
|
|
add_kb_button( "x" );
|
|
add_kb_button( "z" );
|
|
add_button( "del" );
|
|
add_kb_button( "end" );
|
|
add_kb_button( "tab" );
|
|
add_kb_button( "ins" );
|
|
add_kb_button( "add" );
|
|
add_kb_button( "space" );
|
|
add_kb_button( "enter" );
|
|
add_kb_button( "leftarrow" );
|
|
add_kb_button( "rightarrow" );
|
|
add_kb_button( "1" );
|
|
add_kb_button( "2" );
|
|
add_kb_button( "3" );
|
|
add_kb_button( "4" );
|
|
add_kb_button( "5" );
|
|
add_kb_button( "6" );
|
|
add_kb_button( "7" );
|
|
add_kb_button( "8" );
|
|
add_kb_button( "9" );
|
|
add_kb_button( "0" );
|
|
add_kb_button( "~" );
|
|
}
|
|
|
|
locked( name )
|
|
{
|
|
if ( isDefined( level.createfx_lockedlist[ name ] ) )
|
|
{
|
|
return 0;
|
|
}
|
|
return kb_locked( name );
|
|
}
|
|
|
|
kb_locked( name )
|
|
{
|
|
if ( level.createfx_inputlocked )
|
|
{
|
|
return isDefined( level.button_is_kb[ name ] );
|
|
}
|
|
}
|
|
|
|
add_button( name )
|
|
{
|
|
player = get_players()[ 0 ];
|
|
if ( locked( name ) )
|
|
{
|
|
return;
|
|
}
|
|
if ( !isDefined( level.buttonisheld[ name ] ) )
|
|
{
|
|
if ( player buttonpressed( name ) )
|
|
{
|
|
level.buttonisheld[ name ] = 1;
|
|
level.buttonclick[ name ] = 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( !player buttonpressed( name ) )
|
|
{
|
|
}
|
|
}
|
|
}
|
|
|
|
add_kb_button( name )
|
|
{
|
|
level.button_is_kb[ name ] = 1;
|
|
add_button( name );
|
|
}
|
|
|
|
set_anglemod_move_vector()
|
|
{
|
|
/#
|
|
ctrlheld = button_is_held( "ctrl", "BUTTON_LSHLDR" );
|
|
players = get_players();
|
|
if ( level.is_camera_on == 1 )
|
|
{
|
|
newmovement = players[ 0 ] getnormalizedmovement();
|
|
dolly_movement = players[ 0 ] getnormalizedcameramovement();
|
|
if ( newmovement[ 1 ] <= -0,3 )
|
|
{
|
|
level.selectedrotate_yaw -= 1;
|
|
}
|
|
else if ( newmovement[ 1 ] >= 0,3 )
|
|
{
|
|
level.selectedrotate_yaw += 1;
|
|
}
|
|
else if ( buttondown( "kp_leftarrow", "DPAD_LEFT" ) )
|
|
{
|
|
if ( level.selectedrotate_yaw < 0 )
|
|
{
|
|
level.selectedrotate_yaw = 0;
|
|
}
|
|
level.selectedrotate_yaw += 0,1;
|
|
}
|
|
else if ( buttondown( "kp_rightarrow", "DPAD_RIGHT" ) )
|
|
{
|
|
if ( level.selectedrotate_yaw > 0 )
|
|
{
|
|
level.selectedrotate_yaw = 0;
|
|
}
|
|
level.selectedrotate_yaw -= 0,1;
|
|
}
|
|
else
|
|
{
|
|
level.selectedrotate_yaw = 0;
|
|
}
|
|
if ( dolly_movement[ 0 ] <= -0,2 )
|
|
{
|
|
level.selectedrotate_pitch += 1;
|
|
}
|
|
else if ( dolly_movement[ 0 ] >= 0,2 )
|
|
{
|
|
level.selectedrotate_pitch -= 1;
|
|
}
|
|
else if ( buttondown( "kp_uparrow", "DPAD_UP" ) )
|
|
{
|
|
if ( level.selectedrotate_pitch < 0 )
|
|
{
|
|
level.selectedrotate_pitch = 0;
|
|
}
|
|
level.selectedrotate_pitch += 0,1;
|
|
}
|
|
else if ( buttondown( "kp_downarrow", "DPAD_DOWN" ) )
|
|
{
|
|
if ( level.selectedrotate_pitch > 0 )
|
|
{
|
|
level.selectedrotate_pitch = 0;
|
|
}
|
|
level.selectedrotate_pitch -= 0,1;
|
|
}
|
|
else
|
|
{
|
|
level.selectedrotate_pitch = 0;
|
|
}
|
|
if ( buttondown( "BUTTON_Y" ) )
|
|
{
|
|
if ( level.selectedrotate_roll < 0 )
|
|
{
|
|
level.selectedrotate_roll = 0;
|
|
}
|
|
level.selectedrotate_roll += 0,1;
|
|
}
|
|
else if ( buttondown( "BUTTON_B" ) )
|
|
{
|
|
if ( level.selectedrotate_roll > 0 )
|
|
{
|
|
level.selectedrotate_roll = 0;
|
|
}
|
|
level.selectedrotate_roll -= 0,1;
|
|
}
|
|
else
|
|
{
|
|
level.selectedrotate_roll = 0;
|
|
}
|
|
}
|
|
else if ( buttondown( "kp_uparrow", "DPAD_UP" ) )
|
|
{
|
|
if ( level.selectedrotate_pitch < 0 )
|
|
{
|
|
level.selectedrotate_pitch = 0;
|
|
}
|
|
if ( ctrlheld )
|
|
{
|
|
level.selectedrotate_pitch = 0,1;
|
|
wait 0,05;
|
|
}
|
|
else
|
|
{
|
|
level.selectedrotate_pitch += 1;
|
|
}
|
|
}
|
|
else if ( buttondown( "kp_downarrow", "DPAD_DOWN" ) )
|
|
{
|
|
if ( level.selectedrotate_pitch > 0 )
|
|
{
|
|
level.selectedrotate_pitch = 0;
|
|
}
|
|
if ( ctrlheld )
|
|
{
|
|
level.selectedrotate_pitch = -1 * 0,1;
|
|
wait 0,05;
|
|
}
|
|
else
|
|
{
|
|
level.selectedrotate_pitch -= 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
level.selectedrotate_pitch = 0;
|
|
}
|
|
if ( buttondown( "kp_leftarrow", "DPAD_LEFT" ) )
|
|
{
|
|
if ( level.selectedrotate_yaw < 0 )
|
|
{
|
|
level.selectedrotate_yaw = 0;
|
|
}
|
|
if ( ctrlheld )
|
|
{
|
|
level.selectedrotate_yaw = 0,1;
|
|
wait 0,05;
|
|
}
|
|
else
|
|
{
|
|
level.selectedrotate_yaw += 1;
|
|
}
|
|
}
|
|
else if ( buttondown( "kp_rightarrow", "DPAD_RIGHT" ) )
|
|
{
|
|
if ( level.selectedrotate_yaw > 0 )
|
|
{
|
|
level.selectedrotate_yaw = 0;
|
|
}
|
|
if ( ctrlheld )
|
|
{
|
|
level.selectedrotate_yaw = -1 * 0,1;
|
|
wait 0,05;
|
|
}
|
|
else
|
|
{
|
|
level.selectedrotate_yaw -= 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
level.selectedrotate_yaw = 0;
|
|
}
|
|
if ( buttondown( "BUTTON_Y" ) )
|
|
{
|
|
if ( level.selectedrotate_roll < 0 )
|
|
{
|
|
level.selectedrotate_roll = 0;
|
|
}
|
|
if ( ctrlheld )
|
|
{
|
|
level.selectedrotate_roll = 0,1;
|
|
wait 0,05;
|
|
}
|
|
else
|
|
{
|
|
level.selectedrotate_roll += 1;
|
|
}
|
|
}
|
|
else if ( buttondown( "BUTTON_B" ) )
|
|
{
|
|
if ( level.selectedrotate_roll > 0 )
|
|
{
|
|
level.selectedrotate_roll = 0;
|
|
}
|
|
if ( ctrlheld )
|
|
{
|
|
level.selectedrotate_roll = -1 * 0,1;
|
|
wait 0,05;
|
|
}
|
|
else
|
|
{
|
|
level.selectedrotate_roll -= 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
level.selectedrotate_roll = 0;
|
|
#/
|
|
}
|
|
}
|
|
|
|
cfxprintln( file, string )
|
|
{
|
|
/#
|
|
if ( file == -1 )
|
|
{
|
|
return;
|
|
}
|
|
fprintln( file, string );
|
|
#/
|
|
}
|
|
|
|
update_save_bar( number )
|
|
{
|
|
level notify( "saving_start" );
|
|
level endon( "saving_start" );
|
|
level.current_saving_number = 0;
|
|
while ( level.current_saving_number < level.createfxent.size )
|
|
{
|
|
center_text_clear();
|
|
center_text_add( "Saving Createfx to File" );
|
|
center_text_add( "Saving effect " + level.current_saving_number + "/" + level.createfxent.size );
|
|
center_text_add( "Do not reset Xenon until saving is complete." );
|
|
wait 0,05;
|
|
center_text_clear();
|
|
}
|
|
center_text_add( "Saving Complete." );
|
|
center_text_add( level.createfxent.size + " effects saved to files." );
|
|
}
|
|
|
|
generate_fx_log( type, autosave )
|
|
{
|
|
/#
|
|
autosave = isDefined( autosave );
|
|
if ( type == "server" )
|
|
{
|
|
if ( !autosave )
|
|
{
|
|
filename = level.cfx_server_scriptdata + level.script + "_fx.gsc";
|
|
}
|
|
else
|
|
{
|
|
filename = level.cfx_server_scriptdata + "backup.gsc";
|
|
}
|
|
call_loop = level.cfx_server_loop;
|
|
call_oneshot = level.cfx_server_oneshot;
|
|
call_exploder = level.cfx_server_exploder;
|
|
call_loopsound = level.cfx_server_loopsound;
|
|
}
|
|
else if ( type == "client" )
|
|
{
|
|
if ( !autosave )
|
|
{
|
|
filename = level.cfx_client_scriptdata + level.script + "_fx.csc";
|
|
}
|
|
else
|
|
{
|
|
filename = level.cfx_client_scriptdata + "backup.csc";
|
|
}
|
|
call_loop = level.cfx_client_loop;
|
|
call_oneshot = level.cfx_client_oneshot;
|
|
call_exploder = level.cfx_client_exploder;
|
|
call_loopsound = level.cfx_client_loopsound;
|
|
}
|
|
else
|
|
{
|
|
println( "^1Error: Improper type in generate_fx_log()" );
|
|
return;
|
|
}
|
|
file = openfile( filename, "write" );
|
|
if ( file == -1 )
|
|
{
|
|
level.write_error = filename;
|
|
if ( type == "server" )
|
|
{
|
|
return 1;
|
|
}
|
|
else
|
|
{
|
|
if ( type == "client" )
|
|
{
|
|
return 2;
|
|
}
|
|
else
|
|
{
|
|
return 3;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
cfxprintln( file, "//_createfx generated. Do not touch!!" );
|
|
cfxprintln( file, "main()" );
|
|
cfxprintln( file, "{" );
|
|
p = 0;
|
|
while ( p < level.createfxent.size )
|
|
{
|
|
ent = level.createfxent[ p ];
|
|
origin = [];
|
|
angles = [];
|
|
i = 0;
|
|
while ( i < 3 )
|
|
{
|
|
origin[ i ] = ent.v[ "origin" ][ i ];
|
|
angles[ i ] = ent.v[ "angles" ][ i ];
|
|
if ( origin[ i ] < 0,1 && origin[ i ] > ( 0,1 * -1 ) )
|
|
{
|
|
origin[ i ] = 0;
|
|
}
|
|
if ( angles[ i ] < 0,1 && angles[ i ] > ( 0,1 * -1 ) )
|
|
{
|
|
angles[ i ] = 0;
|
|
}
|
|
i++;
|
|
}
|
|
ent.v[ "origin" ] = ( origin[ 0 ], origin[ 1 ], origin[ 2 ] );
|
|
ent.v[ "angles" ] = ( angles[ 0 ], angles[ 1 ], angles[ 2 ] );
|
|
p++;
|
|
}
|
|
if ( !autosave )
|
|
{
|
|
println( " *** CREATING EFFECT, COPY THESE LINES TO ", level.script, "_fx.gsc *** " );
|
|
}
|
|
cfxprintln( file, "// CreateFX entities placed: " + ( level.createfxent.size - level.non_fx_ents ) );
|
|
breather = 0;
|
|
if ( autosave )
|
|
{
|
|
breather_pause = 1;
|
|
}
|
|
else
|
|
{
|
|
breather_pause = 5;
|
|
}
|
|
i = 0;
|
|
while ( i < level.createfxent.size )
|
|
{
|
|
e = level.createfxent[ i ];
|
|
assert( isDefined( e.v[ "type" ] ), "effect at origin " + e.v[ "origin" ] + " has no type" );
|
|
if ( isDefined( e.model ) )
|
|
{
|
|
i++;
|
|
continue;
|
|
}
|
|
else if ( e.v[ "fxid" ] == "No FX" )
|
|
{
|
|
i++;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
output_name = "\t";
|
|
output_props = "\t";
|
|
ent_type = e.v[ "type" ];
|
|
if ( ent_type == "loopfx" )
|
|
{
|
|
output_name += "ent = " + call_loop + "( "" + e.v[ "fxid" ] + "" );";
|
|
}
|
|
if ( ent_type == "oneshotfx" )
|
|
{
|
|
output_name += "ent = " + call_oneshot + "( "" + e.v[ "fxid" ] + "" );";
|
|
}
|
|
if ( ent_type == "exploder" )
|
|
{
|
|
output_name += "ent = " + call_exploder + "( "" + e.v[ "fxid" ] + "" );";
|
|
}
|
|
if ( ent_type == "soundfx" )
|
|
{
|
|
output_name += "ent = " + call_loopsound + "();";
|
|
}
|
|
output_props += get_fx_options( e );
|
|
cfxprintln( file, output_name );
|
|
cfxprintln( file, output_props );
|
|
cfxprintln( file, "\t" );
|
|
breather++;
|
|
if ( breather >= breather_pause )
|
|
{
|
|
wait 0,05;
|
|
breather = 0;
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
if ( level.bscriptgened )
|
|
{
|
|
script_gen_dump_addline( level.cfx_server_scriptgendump, level.script + "_fx" );
|
|
[[ level.cfx_func_script_gen_dump ]]();
|
|
}
|
|
cfxprintln( file, "}" );
|
|
saved = closefile( file );
|
|
assert( saved == 1, "File not saved (see above message?): " + filename );
|
|
println( "CreateFX entities placed: " + ( level.createfxent.size - level.non_fx_ents ) );
|
|
return 0;
|
|
#/
|
|
}
|
|
}
|
|
|
|
get_fx_options( ent )
|
|
{
|
|
output_props = "";
|
|
i = 0;
|
|
while ( i < level.createfx_options.size )
|
|
{
|
|
option = level.createfx_options[ i ];
|
|
if ( !isDefined( ent.v[ option[ "name" ] ] ) )
|
|
{
|
|
i++;
|
|
continue;
|
|
}
|
|
else if ( !mask( option[ "mask" ], ent.v[ "type" ] ) )
|
|
{
|
|
i++;
|
|
continue;
|
|
}
|
|
else if ( option[ "type" ] == "string" )
|
|
{
|
|
if ( option[ "name" ] == "fxid" )
|
|
{
|
|
i++;
|
|
continue;
|
|
}
|
|
else output_props += "ent.v[ "" + option[ "name" ] + "" ] = "" + ent.v[ option[ "name" ] ] + ""; ";
|
|
i++;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
output_props += "ent.v[ "" + option[ "name" ] + "" ] = " + ent.v[ option[ "name" ] ] + "; ";
|
|
}
|
|
i++;
|
|
}
|
|
return output_props;
|
|
}
|
|
|
|
entity_highlight_disable()
|
|
{
|
|
self notify( "highlight change" );
|
|
self endon( "highlight change" );
|
|
for ( ;; )
|
|
{
|
|
self.textalpha -= 0,05;
|
|
if ( self.textalpha < 0,4 )
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
wait 0,05;
|
|
}
|
|
}
|
|
self.textalpha = 0,4;
|
|
}
|
|
|
|
entity_highlight_enable()
|
|
{
|
|
self notify( "highlight change" );
|
|
self endon( "highlight change" );
|
|
for ( ;; )
|
|
{
|
|
self.textalpha += 0,05;
|
|
if ( self.textalpha > 1 )
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
wait 0,05;
|
|
}
|
|
}
|
|
self.textalpha = 1;
|
|
}
|
|
|
|
get_center_of_array( array )
|
|
{
|
|
center = ( 1, 1, 1 );
|
|
i = 0;
|
|
while ( i < array.size )
|
|
{
|
|
center = ( center[ 0 ] + array[ i ].v[ "origin" ][ 0 ], center[ 1 ] + array[ i ].v[ "origin" ][ 1 ], center[ 2 ] + array[ i ].v[ "origin" ][ 2 ] );
|
|
i++;
|
|
}
|
|
return ( center[ 0 ] / array.size, center[ 1 ] / array.size, center[ 2 ] / array.size );
|
|
}
|
|
|
|
rotation_is_occuring()
|
|
{
|
|
if ( level.selectedrotate_roll != 0 )
|
|
{
|
|
return 1;
|
|
}
|
|
if ( level.selectedrotate_pitch != 0 )
|
|
{
|
|
return 1;
|
|
}
|
|
return level.selectedrotate_yaw != 0;
|
|
}
|
|
|
|
process_fx_rotater()
|
|
{
|
|
if ( level.fx_rotating )
|
|
{
|
|
return;
|
|
}
|
|
set_anglemod_move_vector();
|
|
if ( !rotation_is_occuring() )
|
|
{
|
|
return;
|
|
}
|
|
level.fx_rotating = 1;
|
|
if ( level.cfx_last_action != "rotate" )
|
|
{
|
|
store_undo_state( "edit", level.selected_fx_ents );
|
|
level.cfx_last_action = "rotate";
|
|
}
|
|
if ( level.selected_fx_ents.size > 1 )
|
|
{
|
|
center = get_center_of_array( level.selected_fx_ents );
|
|
org = spawn( "script_origin", center );
|
|
org.v[ "angles" ] = level.selected_fx_ents[ 0 ].v[ "angles" ];
|
|
org.v[ "origin" ] = center;
|
|
rotater = [];
|
|
i = 0;
|
|
while ( i < level.selected_fx_ents.size )
|
|
{
|
|
rotater[ i ] = spawn( "script_origin", level.selected_fx_ents[ i ].v[ "origin" ] );
|
|
rotater[ i ].angles = level.selected_fx_ents[ i ].v[ "angles" ];
|
|
rotater[ i ] linkto( org );
|
|
i++;
|
|
}
|
|
rotate_over_time( org, rotater );
|
|
org delete();
|
|
i = 0;
|
|
while ( i < rotater.size )
|
|
{
|
|
rotater[ i ] delete();
|
|
i++;
|
|
}
|
|
}
|
|
else if ( level.selected_fx_ents.size == 1 )
|
|
{
|
|
ent = level.selected_fx_ents[ 0 ];
|
|
rotater = spawn( "script_origin", ( 1, 1, 1 ) );
|
|
rotater.angles = ent.v[ "angles" ];
|
|
if ( level.selectedrotate_pitch != 0 )
|
|
{
|
|
rotater devaddpitch( level.selectedrotate_pitch );
|
|
}
|
|
else if ( level.selectedrotate_yaw != 0 )
|
|
{
|
|
rotater devaddyaw( level.selectedrotate_yaw );
|
|
}
|
|
else
|
|
{
|
|
rotater devaddroll( level.selectedrotate_roll );
|
|
}
|
|
ent.v[ "angles" ] = rotater.angles;
|
|
rotater delete();
|
|
wait 0,05;
|
|
}
|
|
level.fx_rotating = 0;
|
|
}
|
|
|
|
rotate_over_time( org, rotater )
|
|
{
|
|
level endon( "new_ent_selection" );
|
|
p = 0;
|
|
while ( p < 2 )
|
|
{
|
|
if ( level.selectedrotate_pitch != 0 )
|
|
{
|
|
org devaddpitch( level.selectedrotate_pitch );
|
|
}
|
|
else if ( level.selectedrotate_yaw != 0 )
|
|
{
|
|
org devaddyaw( level.selectedrotate_yaw );
|
|
}
|
|
else
|
|
{
|
|
org devaddroll( level.selectedrotate_roll );
|
|
}
|
|
wait 0,05;
|
|
i = 0;
|
|
while ( i < level.selected_fx_ents.size )
|
|
{
|
|
ent = level.selected_fx_ents[ i ];
|
|
if ( isDefined( ent.model ) )
|
|
{
|
|
i++;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
ent.v[ "origin" ] = rotater[ i ].origin;
|
|
ent.v[ "angles" ] = rotater[ i ].angles;
|
|
}
|
|
i++;
|
|
}
|
|
p++;
|
|
}
|
|
}
|
|
|
|
delete_pressed()
|
|
{
|
|
if ( level.createfx_inputlocked )
|
|
{
|
|
remove_selected_option();
|
|
return;
|
|
}
|
|
delete_selection();
|
|
}
|
|
|
|
remove_selected_option()
|
|
{
|
|
if ( !isDefined( level.selected_fx_option_index ) )
|
|
{
|
|
return;
|
|
}
|
|
name = level.createfx_options[ level.selected_fx_option_index ][ "name" ];
|
|
i = 0;
|
|
while ( i < level.createfxent.size )
|
|
{
|
|
ent = level.createfxent[ i ];
|
|
if ( !ent_is_selected( ent ) )
|
|
{
|
|
i++;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
ent remove_option( name );
|
|
}
|
|
i++;
|
|
}
|
|
update_selected_entities();
|
|
clear_settable_fx();
|
|
}
|
|
|
|
remove_option( name )
|
|
{
|
|
}
|
|
|
|
delete_selection()
|
|
{
|
|
newarray = [];
|
|
if ( level.selected_fx_ents.size < 1 )
|
|
{
|
|
return;
|
|
}
|
|
store_undo_state( "delete", level.selected_fx_ents );
|
|
level.cfx_last_action = "none";
|
|
i = 0;
|
|
while ( i < level.createfxent.size )
|
|
{
|
|
ent = level.createfxent[ i ];
|
|
if ( ent_is_selected( ent ) )
|
|
{
|
|
if ( isDefined( ent.looper ) )
|
|
{
|
|
ent.looper delete();
|
|
}
|
|
level.fx_highlightedent = undefined;
|
|
ent notify( "stop_loop" );
|
|
i++;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
newarray[ newarray.size ] = ent;
|
|
}
|
|
i++;
|
|
}
|
|
level.createfxent = newarray;
|
|
level.selected_fx = [];
|
|
level.selected_fx_ents = [];
|
|
clear_fx_hudelements();
|
|
}
|
|
|
|
move_selection_to_cursor( skip_undo )
|
|
{
|
|
origin = level.createfxcursor[ "position" ];
|
|
if ( level.selected_fx_ents.size <= 0 )
|
|
{
|
|
return;
|
|
}
|
|
if ( !isDefined( skip_undo ) && level.cfx_last_action != "move_to_cursor" )
|
|
{
|
|
store_undo_state( "edit", level.selected_fx_ents );
|
|
level.cfx_last_action = "move_to_cursor";
|
|
}
|
|
center = get_center_of_array( level.selected_fx_ents );
|
|
difference = center - origin;
|
|
i = 0;
|
|
while ( i < level.selected_fx_ents.size )
|
|
{
|
|
ent = level.selected_fx_ents[ i ];
|
|
if ( isDefined( ent.model ) )
|
|
{
|
|
i++;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
ent.v[ "origin" ] -= difference;
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
|
|
insert_effect()
|
|
{
|
|
setmenu( "creation" );
|
|
level.effect_list_offset = 0;
|
|
clear_fx_hudelements();
|
|
set_fx_hudelement( "Pick effect type to create:" );
|
|
set_fx_hudelement( "1. One Shot fx" );
|
|
set_fx_hudelement( "2. Looping fx" );
|
|
set_fx_hudelement( "3. Exploder" );
|
|
set_fx_hudelement( "4. Looping sound" );
|
|
set_fx_hudelement( "(c) Cancel" );
|
|
set_fx_hudelement( "(x) Exit" );
|
|
}
|
|
|
|
show_help()
|
|
{
|
|
clear_fx_hudelements();
|
|
set_fx_hudelement( "Help:" );
|
|
set_fx_hudelement( "I Insert effect" );
|
|
set_fx_hudelement( "Shift + D Delete selected effects" );
|
|
set_fx_hudelement( "F + 5 Save" );
|
|
set_fx_hudelement( "A button Toggle the selection of the current effect" );
|
|
set_fx_hudelement( "X button Toggle effect rotation mode" );
|
|
set_fx_hudelement( "Y button Move selected effects up or rotate X axis" );
|
|
set_fx_hudelement( "B button Move selected effects down or rotate X axis" );
|
|
set_fx_hudelement( "D-pad Up/Down Move selected effects Forward/Backward or rotate Y axis" );
|
|
set_fx_hudelement( "D-pad Left/Right Move selected effects Left/Right or rotate Z axis" );
|
|
set_fx_hudelement( "R Shoulder Move selected effects to the cursor" );
|
|
set_fx_hudelement( "L Shoulder Hold to select multiple effects" );
|
|
set_fx_hudelement( "Right Arrow Next page in options menu" );
|
|
set_fx_hudelement( "Left Arrow Previous page in options menu" );
|
|
set_fx_hudelement( "A Add option to the selected effects" );
|
|
set_fx_hudelement( "X Exit effect options menu" );
|
|
set_fx_hudelement( "Shift + D Drop selected effects to the ground" );
|
|
set_fx_hudelement( "R Reset the rotation of the selected effects" );
|
|
set_fx_hudelement( "L Stick Copy effects" );
|
|
set_fx_hudelement( "R Stick Paste effects" );
|
|
set_fx_hudelement( "V Copy the angles from the most recently selected fx onto all selected fx." );
|
|
set_fx_hudelement( "F + 2 Toggle CreateFX dot and menu drawing" );
|
|
set_fx_hudelement( "U UFO" );
|
|
set_fx_hudelement( "N Noclip" );
|
|
set_fx_hudelement( "R Trig + L Trig Jump forward 8000 units" );
|
|
set_fx_hudelement( "T Toggle Timescale FAST" );
|
|
set_fx_hudelement( "Y Toggle Timescale SLOW" );
|
|
set_fx_hudelement( "H Toggle FX Visibility" );
|
|
set_fx_hudelement( "W Toggle effect wireframe" );
|
|
set_fx_hudelement( "P Toggle FX Profile" );
|
|
}
|
|
|
|
center_text_init()
|
|
{
|
|
level.cfx_center_text = [];
|
|
level.cfx_center_text_index = 0;
|
|
level.cfx_center_text_max = 3;
|
|
new_array = [];
|
|
p = 0;
|
|
while ( p < level.cfx_center_text_max )
|
|
{
|
|
center_hud = newdebughudelem();
|
|
center_hud settext( " " );
|
|
center_hud.horzalign = "center";
|
|
center_hud.vertalign = "middle";
|
|
center_hud.alignx = "center";
|
|
center_hud.aligny = "middle";
|
|
center_hud.foreground = 1;
|
|
center_hud.fontscale = 1,1;
|
|
center_hud.sort = 21;
|
|
center_hud.alpha = 1;
|
|
center_hud.color = ( 1, 1, 1 );
|
|
center_hud.y = p * 25;
|
|
new_array[ p ] = center_hud;
|
|
p++;
|
|
}
|
|
level.cfx_center_text = new_array;
|
|
}
|
|
|
|
center_text_add( text )
|
|
{
|
|
if ( isDefined( text ) && isDefined( level.cfx_center_text ) )
|
|
{
|
|
level.cfx_center_text[ level.cfx_center_text_index ] settext( text );
|
|
level.cfx_center_text_index++;
|
|
if ( level.cfx_center_text_index >= level.cfx_center_text_max )
|
|
{
|
|
level.cfx_center_text_index = level.cfx_center_text_max - 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
center_text_clear()
|
|
{
|
|
p = 0;
|
|
while ( p < level.cfx_center_text_max )
|
|
{
|
|
level.cfx_center_text[ p ] settext( " " );
|
|
p++;
|
|
}
|
|
level.cfx_center_text_index = 0;
|
|
}
|
|
|
|
write_error_msg( filename )
|
|
{
|
|
level notify( "write_error" );
|
|
level endon( "write_error" );
|
|
while ( isDefined( filename ) )
|
|
{
|
|
center_text_clear();
|
|
center_text_add( "File " + filename + " is not writeable." );
|
|
center_text_add( "If it's checked out, restart your computer!" );
|
|
center_text_add( "Hold the A Button to dismiss." );
|
|
for ( ;; )
|
|
{
|
|
player = get_players()[ 0 ];
|
|
if ( player buttonpressed( "BUTTON_A" ) )
|
|
{
|
|
center_text_clear();
|
|
level.write_error = "";
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
wait 0,25;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
select_last_entity( skip_undo )
|
|
{
|
|
select_entity( level.createfxent.size - 1, level.createfxent[ level.createfxent.size - 1 ], skip_undo );
|
|
}
|
|
|
|
post_entity_creation_function()
|
|
{
|
|
self.textalpha = 0;
|
|
self.drawn = 1;
|
|
}
|
|
|
|
copy_ents()
|
|
{
|
|
if ( level.selected_fx_ents.size <= 0 )
|
|
{
|
|
return;
|
|
}
|
|
array = [];
|
|
i = 0;
|
|
while ( i < level.selected_fx_ents.size )
|
|
{
|
|
ent = level.selected_fx_ents[ i ];
|
|
newent = spawnstruct();
|
|
newent.v = ent.v;
|
|
newent post_entity_creation_function();
|
|
array[ array.size ] = newent;
|
|
i++;
|
|
}
|
|
level.stored_ents = array;
|
|
}
|
|
|
|
paste_ents()
|
|
{
|
|
delay_min = getDvarInt( "createfx_oneshot_min_delay" );
|
|
delay_max = getDvarInt( "createfx_oneshot_max_delay" );
|
|
if ( delay_min > delay_max )
|
|
{
|
|
temp = delay_min;
|
|
delay_min = delay_max;
|
|
delay_max = temp;
|
|
}
|
|
if ( !isDefined( level.stored_ents ) )
|
|
{
|
|
return;
|
|
}
|
|
clear_entity_selection();
|
|
if ( level.cfx_last_action != "none" )
|
|
{
|
|
store_undo_state( "edit", level.selected_fx_ents );
|
|
}
|
|
level.cfx_last_action = "none";
|
|
i = 0;
|
|
while ( i < level.stored_ents.size )
|
|
{
|
|
level.stored_ents[ i ].uniqueid = level.cfx_uniqueid;
|
|
level.cfx_uniqueid++;
|
|
if ( level.stored_ents[ i ].v[ "type" ] == "oneshotfx" )
|
|
{
|
|
level.stored_ents[ i ].v[ "delay" ] = randomintrange( delay_min, delay_max );
|
|
}
|
|
add_and_select_entity( level.stored_ents[ i ], "skip_undo" );
|
|
i++;
|
|
}
|
|
move_selection_to_cursor( "skip_undo" );
|
|
update_selected_entities();
|
|
store_undo_state( "add", level.stored_ents );
|
|
level.stored_ents = [];
|
|
copy_ents();
|
|
}
|
|
|
|
paste_ents_onto_ents()
|
|
{
|
|
if ( !isDefined( level.stored_ents ) || !isDefined( level.selected_fx_ents ) )
|
|
{
|
|
return;
|
|
}
|
|
if ( level.stored_ents.size < 1 || level.selected_fx_ents.size < 1 )
|
|
{
|
|
return;
|
|
}
|
|
if ( level.stored_ents.size != level.selected_fx_ents.size )
|
|
{
|
|
/#
|
|
println( "^2CreateFX: Number of source ents must match the number of destination ents for Paste Into to work." );
|
|
#/
|
|
return;
|
|
}
|
|
if ( level.cfx_last_action != "none" )
|
|
{
|
|
store_undo_state( "edit", level.selected_fx_ents );
|
|
}
|
|
level.cfx_last_action = "none";
|
|
selected_ents_temp = level.selected_fx_ents;
|
|
i = 0;
|
|
while ( i < level.stored_ents.size )
|
|
{
|
|
source_ent = level.stored_ents[ i ];
|
|
target_ent = level.selected_fx_ents[ i ];
|
|
source_ent.uniqueid = level.cfx_uniqueid;
|
|
level.cfx_uniqueid++;
|
|
source_ent.v[ "angles" ] = target_ent.v[ "angles" ];
|
|
source_ent.v[ "origin" ] = target_ent.v[ "origin" ];
|
|
add_and_select_entity( source_ent, "skip_undo" );
|
|
i++;
|
|
}
|
|
i = 0;
|
|
while ( i < selected_ents_temp.size )
|
|
{
|
|
deselect_entity( selected_ents_temp[ i ].last_fx_index, selected_ents_temp[ i ] );
|
|
i++;
|
|
}
|
|
update_selected_entities();
|
|
store_undo_state( "add", level.stored_ents );
|
|
level.stored_ents = [];
|
|
copy_ents();
|
|
}
|
|
|
|
add_and_select_entity( ent, skip_undo )
|
|
{
|
|
level.createfxent[ level.createfxent.size ] = ent;
|
|
select_last_entity( skip_undo );
|
|
}
|
|
|
|
stop_fx_looper()
|
|
{
|
|
if ( isDefined( self.looper ) )
|
|
{
|
|
self.looper delete();
|
|
}
|
|
self [[ level.cfx_func_stop_loopsound ]]();
|
|
}
|
|
|
|
restart_fx_looper()
|
|
{
|
|
stop_fx_looper();
|
|
self set_forward_and_up_vectors();
|
|
if ( self.v[ "type" ] == "loopfx" )
|
|
{
|
|
self [[ level.cfx_func_create_looper ]]();
|
|
}
|
|
if ( self.v[ "type" ] == "oneshotfx" )
|
|
{
|
|
self [[ level.cfx_func_create_triggerfx ]]();
|
|
}
|
|
if ( self.v[ "type" ] == "soundfx" )
|
|
{
|
|
self [[ level.cfx_func_create_loopsound ]]();
|
|
}
|
|
}
|
|
|
|
update_selected_entities()
|
|
{
|
|
i = 0;
|
|
while ( i < level.selected_fx_ents.size )
|
|
{
|
|
ent = level.selected_fx_ents[ i ];
|
|
ent restart_fx_looper();
|
|
i++;
|
|
}
|
|
}
|
|
|
|
copy_angles_of_selected_ents()
|
|
{
|
|
level notify( "new_ent_selection" );
|
|
if ( level.cfx_last_action != "copy_angles" )
|
|
{
|
|
store_undo_state( "edit", level.selected_fx_ents );
|
|
level.cfx_last_action = "copy_angles";
|
|
}
|
|
i = 0;
|
|
while ( i < level.selected_fx_ents.size )
|
|
{
|
|
ent = level.selected_fx_ents[ i ];
|
|
ent.v[ "angles" ] = level.selected_fx_ents[ level.selected_fx_ents.size - 1 ].v[ "angles" ];
|
|
ent set_forward_and_up_vectors();
|
|
i++;
|
|
}
|
|
update_selected_entities();
|
|
}
|
|
|
|
reset_axis_of_selected_ents()
|
|
{
|
|
level notify( "new_ent_selection" );
|
|
if ( level.cfx_last_action != "reset_axis" )
|
|
{
|
|
store_undo_state( "edit", level.selected_fx_ents );
|
|
level.cfx_last_action = "reset_axis";
|
|
}
|
|
i = 0;
|
|
while ( i < level.selected_fx_ents.size )
|
|
{
|
|
ent = level.selected_fx_ents[ i ];
|
|
ent.v[ "angles" ] = ( 1, 1, 1 );
|
|
ent set_forward_and_up_vectors();
|
|
i++;
|
|
}
|
|
update_selected_entities();
|
|
}
|
|
|
|
last_selected_entity_has_changed( lastselectentity )
|
|
{
|
|
if ( isDefined( lastselectentity ) )
|
|
{
|
|
if ( !entities_are_selected() )
|
|
{
|
|
return 1;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return entities_are_selected();
|
|
}
|
|
return lastselectentity != level.selected_fx_ents[ level.selected_fx_ents.size - 1 ];
|
|
}
|
|
|
|
createfx_showorigin( id, org, delay, org2, type, exploder, id2, firefx, firefxdelay, firefxsound, fxsound, fxquake, fxdamage, soundalias, repeat, delay_min, delay_max, damage_radius, firefxtimeout )
|
|
{
|
|
}
|
|
|
|
drop_selection_to_ground()
|
|
{
|
|
if ( level.cfx_last_action != "drop_to_ground" )
|
|
{
|
|
store_undo_state( "edit", level.selected_fx_ents );
|
|
level.cfx_last_action = "drop_to_ground";
|
|
}
|
|
i = 0;
|
|
while ( i < level.selected_fx_ents.size )
|
|
{
|
|
ent = level.selected_fx_ents[ i ];
|
|
trace = bullettrace( ent.v[ "origin" ], ent.v[ "origin" ] + vectorScale( ( 1, 1, 1 ), 2048 ), 0, undefined );
|
|
ent.v[ "origin" ] = trace[ "position" ];
|
|
i++;
|
|
}
|
|
}
|
|
|
|
set_off_exploders()
|
|
{
|
|
level notify( "createfx_exploder_reset" );
|
|
exploders = [];
|
|
i = 0;
|
|
while ( i < level.selected_fx_ents.size )
|
|
{
|
|
ent = level.selected_fx_ents[ i ];
|
|
if ( isDefined( ent.v[ "exploder" ] ) )
|
|
{
|
|
exploders[ ent.v[ "exploder" ] ] = 1;
|
|
}
|
|
i++;
|
|
}
|
|
keys = getarraykeys( exploders );
|
|
i = 0;
|
|
while ( i < keys.size )
|
|
{
|
|
exploder( keys[ i ] );
|
|
i++;
|
|
}
|
|
}
|
|
|
|
turn_off_exploders()
|
|
{
|
|
level notify( "createfx_exploder_reset" );
|
|
exploders = [];
|
|
i = 0;
|
|
while ( i < level.selected_fx_ents.size )
|
|
{
|
|
ent = level.selected_fx_ents[ i ];
|
|
if ( isDefined( ent.v[ "exploder" ] ) )
|
|
{
|
|
exploders[ ent.v[ "exploder" ] ] = 1;
|
|
}
|
|
i++;
|
|
}
|
|
keys = getarraykeys( exploders );
|
|
i = 0;
|
|
while ( i < keys.size )
|
|
{
|
|
stop_exploder( keys[ i ] );
|
|
i++;
|
|
}
|
|
}
|
|
|
|
draw_distance()
|
|
{
|
|
count = 0;
|
|
last_pos = ( 1, 1, 1 );
|
|
if ( getDvarInt( "createfx_drawdist" ) == 0 )
|
|
{
|
|
setdvar( "createfx_drawdist", "1500" );
|
|
}
|
|
player = get_players()[ 0 ];
|
|
for ( ;; )
|
|
{
|
|
maxdist = getDvarInt( "createfx_drawdist" );
|
|
maxdistsqr = maxdist * maxdist;
|
|
/#
|
|
if ( flag( "createfx_saving" ) )
|
|
{
|
|
println( "Waiting for createfx to save..." );
|
|
#/
|
|
}
|
|
flag_waitopen( "createfx_saving" );
|
|
i = 0;
|
|
while ( i < level.createfxent.size )
|
|
{
|
|
ent = level.createfxent[ i ];
|
|
if ( ent_is_selected( ent ) )
|
|
{
|
|
ent.drawn = 1;
|
|
count++;
|
|
continue;
|
|
}
|
|
else
|
|
{
|
|
ent.drawn = distancesquared( player.origin, ent.v[ "origin" ] ) <= maxdistsqr;
|
|
}
|
|
count++;
|
|
if ( count > 50 )
|
|
{
|
|
count = 0;
|
|
wait 0,05;
|
|
}
|
|
i++;
|
|
}
|
|
wait 0,1;
|
|
while ( distancesquared( player.origin, last_pos ) < 2500 )
|
|
{
|
|
wait 0,1;
|
|
}
|
|
last_pos = player.origin;
|
|
}
|
|
}
|
|
|
|
createfx_save( autosave )
|
|
{
|
|
flag_waitopen( "createfx_saving" );
|
|
flag_set( "createfx_saving" );
|
|
resettimeout();
|
|
if ( isDefined( autosave ) )
|
|
{
|
|
savemode = "AUTOSAVE";
|
|
}
|
|
else
|
|
{
|
|
savemode = "USER SAVE";
|
|
}
|
|
type = "server";
|
|
old_time = getTime();
|
|
/#
|
|
println( "\n^3#### CREATEFX SERVER " + savemode + " BEGIN ####" );
|
|
#/
|
|
file_error = generate_fx_log( type, autosave );
|
|
/#
|
|
println( ( "^3#### CREATEFX SERVER " + savemode + " END (Time: " ) + ( ( getTime() - old_time ) * 0,001 ) + " seconds)####" );
|
|
#/
|
|
if ( file_error )
|
|
{
|
|
/#
|
|
println( "^3#### CREATEFX " + savemode + " CANCELLED ####" );
|
|
#/
|
|
createfx_emergency_backup();
|
|
}
|
|
else
|
|
{
|
|
if ( level.clientscripts && !isDefined( autosave ) )
|
|
{
|
|
old_time = getTime();
|
|
/#
|
|
println( "\n^3#### CREATEFX CLIENT " + savemode + " BEGIN ####" );
|
|
#/
|
|
file_error = generate_fx_log( "client" );
|
|
/#
|
|
println( ( "^3#### CREATEFX CLIENT " + savemode + " END (Time: " ) + ( ( getTime() - old_time ) * 0,001 ) + " seconds)####" );
|
|
#/
|
|
if ( file_error )
|
|
{
|
|
/#
|
|
iprintln( "CreateFX clientscript file is not writeable! Aborting save." );
|
|
#/
|
|
/#
|
|
println( "^3#### CREATEFX " + savemode + " CANCELLED ####" );
|
|
#/
|
|
return;
|
|
}
|
|
}
|
|
flag_clear( "createfx_saving" );
|
|
}
|
|
}
|
|
|
|
createfx_autosave()
|
|
{
|
|
for ( ;; )
|
|
{
|
|
wait_time = getDvarInt( "createfx_autosave_time" );
|
|
if ( wait_time < 120 || isstring( wait_time ) )
|
|
{
|
|
wait_time = 120;
|
|
}
|
|
wait wait_time;
|
|
if ( !flag( "createfx_saving" ) )
|
|
{
|
|
createfx_save( 1 );
|
|
}
|
|
}
|
|
}
|
|
|
|
createfx_emergency_backup()
|
|
{
|
|
/#
|
|
println( "^5#### CREATEFX EMERGENCY BACKUP BEGIN ####" );
|
|
#/
|
|
file_error = generate_fx_log( "server", 1 );
|
|
if ( file_error )
|
|
{
|
|
/#
|
|
iprintln( "Error saving to backup.gsc. All is lost!" );
|
|
#/
|
|
}
|
|
else
|
|
{
|
|
/#
|
|
println( "^5#### CREATEFX EMERGENCY BACKUP END ####" );
|
|
#/
|
|
}
|
|
flag_clear( "createfx_saving" );
|
|
}
|
|
|
|
move_player_around_map_fast()
|
|
{
|
|
player = get_players()[ 0 ];
|
|
direction = player getplayerangles();
|
|
direction_vec = anglesToForward( direction );
|
|
eye = player geteye();
|
|
trace = bullettrace( eye, eye + vectorScale( direction_vec, 20000 ), 0, undefined );
|
|
dist = distance( eye, trace[ "position" ] );
|
|
position = eye + vectorScale( direction_vec, dist - 64 );
|
|
player setorigin( position );
|
|
}
|
|
|
|
move_player_to_next_same_effect( forward_search, lastselectentity )
|
|
{
|
|
player = get_players()[ 0 ];
|
|
direction = player getplayerangles();
|
|
direction_vec = anglesToForward( direction );
|
|
if ( !isDefined( forward_search ) )
|
|
{
|
|
forward_search = 1;
|
|
}
|
|
ent = level.selected_fx_ents[ level.selected_fx_ents.size - 1 ];
|
|
start_index = 0;
|
|
if ( level.selected_fx_ents.size <= 0 )
|
|
{
|
|
if ( forward_search )
|
|
{
|
|
ent = level.cfx_next_ent;
|
|
}
|
|
else
|
|
{
|
|
ent = level.cfx_previous_ent;
|
|
}
|
|
if ( isDefined( ent ) )
|
|
{
|
|
index = get_ent_index( ent );
|
|
if ( index >= 0 )
|
|
{
|
|
select_entity( index, ent );
|
|
position = ent.v[ "origin" ] - vectorScale( direction_vec, 175 );
|
|
player setorigin( position );
|
|
level.cfx_previous_ent = ent;
|
|
level.cfx_next_ent = get_next_ent_with_same_id( index, ent.v[ "fxid" ] );
|
|
}
|
|
else if ( forward_search )
|
|
{
|
|
level.cfx_next_ent = undefined;
|
|
}
|
|
else
|
|
{
|
|
level.cfx_previous_ent = undefined;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
if ( level.selected_fx_ents.size == 1 )
|
|
{
|
|
i = 0;
|
|
while ( i < level.createfxent.size )
|
|
{
|
|
if ( isDefined( level.selected_fx[ i ] ) )
|
|
{
|
|
start_index = i;
|
|
deselect_entity( i, ent );
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
i++;
|
|
}
|
|
}
|
|
if ( forward_search )
|
|
{
|
|
level.cfx_previous_ent = ent;
|
|
ent = get_next_ent_with_same_id( i, ent.v[ "fxid" ] );
|
|
select_entity( level.ent_found_index, ent );
|
|
position = ent.v[ "origin" ] - vectorScale( direction_vec, 175 );
|
|
player setorigin( position );
|
|
level.cfx_next_ent = get_next_ent_with_same_id( level.ent_found_index, ent.v[ "fxid" ] );
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
level.cfx_next_ent = ent;
|
|
ent = get_previous_ent_with_same_id( i, ent.v[ "fxid" ] );
|
|
select_entity( level.ent_found_index, ent );
|
|
position = ent.v[ "origin" ] - vectorScale( direction_vec, 175 );
|
|
player setorigin( position );
|
|
level.cfx_previous_ent = get_previous_ent_with_same_id( level.ent_found_index, ent.v[ "fxid" ] );
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( isDefined( level.last_ent_moved_to ) && !last_selected_entity_has_changed( lastselectentity ) )
|
|
{
|
|
ent = level.last_ent_moved_to;
|
|
}
|
|
i = 0;
|
|
while ( i < level.selected_fx_ents.size )
|
|
{
|
|
if ( ent == level.selected_fx_ents[ i ] )
|
|
{
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
i++;
|
|
}
|
|
}
|
|
if ( forward_search )
|
|
{
|
|
if ( i < ( level.selected_fx_ents.size - 1 ) )
|
|
{
|
|
i++;
|
|
ent = level.selected_fx_ents[ i ];
|
|
}
|
|
else
|
|
{
|
|
ent = level.selected_fx_ents[ 0 ];
|
|
}
|
|
}
|
|
else if ( i > 0 )
|
|
{
|
|
ent = level.selected_fx_ents[ i - 1 ];
|
|
}
|
|
else
|
|
{
|
|
ent = level.selected_fx_ents[ level.selected_fx_ents.size - 1 ];
|
|
}
|
|
level.last_ent_moved_to = ent;
|
|
position = ent.v[ "origin" ] - vectorScale( direction_vec, 175 );
|
|
player setorigin( position );
|
|
}
|
|
}
|
|
|
|
get_next_ent_with_same_id( index, ent_id )
|
|
{
|
|
i = index + 1;
|
|
while ( i < level.createfxent.size )
|
|
{
|
|
if ( ent_id == level.createfxent[ i ].v[ "fxid" ] )
|
|
{
|
|
level.ent_found_index = i;
|
|
return level.createfxent[ i ];
|
|
}
|
|
i++;
|
|
}
|
|
i = 0;
|
|
while ( i < index )
|
|
{
|
|
if ( ent_id == level.createfxent[ i ].v[ "fxid" ] )
|
|
{
|
|
level.ent_found_index = i;
|
|
return level.createfxent[ i ];
|
|
}
|
|
i++;
|
|
}
|
|
level.ent_found_index = index;
|
|
return level.createfxent[ index ];
|
|
}
|
|
|
|
get_previous_ent_with_same_id( index, ent_id )
|
|
{
|
|
i = index - 1;
|
|
while ( i > 0 )
|
|
{
|
|
if ( ent_id == level.createfxent[ i ].v[ "fxid" ] )
|
|
{
|
|
level.ent_found_index = i;
|
|
return level.createfxent[ i ];
|
|
}
|
|
i--;
|
|
|
|
}
|
|
i = level.createfxent.size - 1;
|
|
while ( i > index )
|
|
{
|
|
if ( ent_id == level.createfxent[ i ].v[ "fxid" ] )
|
|
{
|
|
level.ent_found_index = i;
|
|
return level.createfxent[ i ];
|
|
}
|
|
i--;
|
|
|
|
}
|
|
level.ent_found_index = index;
|
|
return level.createfxent[ index ];
|
|
}
|
|
|
|
get_ent_index( ent )
|
|
{
|
|
i = 0;
|
|
while ( i < level.createfxent.size )
|
|
{
|
|
if ( ent == level.createfxent[ i ] )
|
|
{
|
|
return i;
|
|
}
|
|
i++;
|
|
}
|
|
return -1;
|
|
}
|
|
|
|
select_ents_by_property( property, add_to_selection )
|
|
{
|
|
ent = level.selected_fx_ents[ level.selected_fx_ents.size - 1 ];
|
|
prop_to_match = ent.v[ property ];
|
|
if ( !isDefined( add_to_selection ) )
|
|
{
|
|
clear_entity_selection();
|
|
}
|
|
i = 0;
|
|
while ( i < level.createfxent.size )
|
|
{
|
|
if ( isDefined( level.createfxent[ i ].v[ property ] ) )
|
|
{
|
|
if ( level.createfxent[ i ].v[ property ] == prop_to_match )
|
|
{
|
|
select_entity( i, level.createfxent[ i ] );
|
|
}
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
|
|
print_ambient_fx_inventory()
|
|
{
|
|
/#
|
|
fx_list = get_level_ambient_fx();
|
|
ent_list = [];
|
|
fx_list_count = [];
|
|
println( "\n\n^2INVENTORY OF AMBIENT EFFECTS: " );
|
|
i = 0;
|
|
while ( i < level.createfxent.size )
|
|
{
|
|
ent_list[ i ] = level.createfxent[ i ].v[ "fxid" ];
|
|
i++;
|
|
}
|
|
i = 0;
|
|
while ( i < fx_list.size )
|
|
{
|
|
count = 0;
|
|
j = 0;
|
|
while ( j < ent_list.size )
|
|
{
|
|
if ( fx_list[ i ] == ent_list[ j ] )
|
|
{
|
|
count++;
|
|
ent_list[ j ] = "";
|
|
}
|
|
j++;
|
|
}
|
|
fx_list_count[ i ] = count;
|
|
i++;
|
|
}
|
|
i = 0;
|
|
while ( i < ( fx_list_count.size - 1 ) )
|
|
{
|
|
j = i + 1;
|
|
while ( j < fx_list_count.size )
|
|
{
|
|
if ( fx_list_count[ j ] < fx_list_count[ i ] )
|
|
{
|
|
temp_count = fx_list_count[ i ];
|
|
temp_id = fx_list[ i ];
|
|
fx_list_count[ i ] = fx_list_count[ j ];
|
|
fx_list[ i ] = fx_list[ j ];
|
|
fx_list_count[ j ] = temp_count;
|
|
fx_list[ j ] = temp_id;
|
|
}
|
|
j++;
|
|
}
|
|
i++;
|
|
}
|
|
i = 0;
|
|
while ( i < fx_list_count.size )
|
|
{
|
|
switch( fx_list_count[ i ] )
|
|
{
|
|
case 0:
|
|
print( "^1" );
|
|
break;
|
|
case 1:
|
|
print( "^3" );
|
|
break;
|
|
default:
|
|
}
|
|
print( fx_list_count[ i ] + "\t" + fx_list[ i ] + "\n" );
|
|
i++;
|
|
}
|
|
print( "\n" );
|
|
#/
|
|
}
|
|
}
|
|
|
|
vector_changed( old, new )
|
|
{
|
|
if ( distancesquared( old, new ) >= 1 )
|
|
{
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
dot_changed( old, new )
|
|
{
|
|
dot = vectordot( old, new );
|
|
if ( dot < 1 )
|
|
{
|
|
return 1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
damage_void( einflictor, eattacker, idamage, idflags, smeansofdeath, sweapon, vpoint, vdir, shitloc, timeoffset, boneindex )
|
|
{
|
|
}
|
|
|
|
handle_camera()
|
|
{
|
|
/#
|
|
level notify( "new_camera" );
|
|
level endon( "new_camera" );
|
|
movement = ( 1, 1, 1 );
|
|
if ( !isDefined( level.camera ) )
|
|
{
|
|
level.camera = spawn( "script_origin", ( 1, 1, 1 ) );
|
|
level.camera setmodel( "tag_origin" );
|
|
}
|
|
players = get_players();
|
|
players[ 0 ] playerlinktodelta( level.camera, "tag_origin", 1, 0, 0, 0, 0, 1 );
|
|
players[ 0 ] disableweapons();
|
|
level.camera_snapto = 1;
|
|
level.stick_camera = 1;
|
|
level.camera_prev_snapto = 0;
|
|
level.cameravec = ( 90, 150, 20 );
|
|
model = undefined;
|
|
n_y_vector = 0;
|
|
n_x_vector = 0;
|
|
zoom_level = 300;
|
|
b_changes_x = 0;
|
|
b_changes_z = 0;
|
|
b_changes_y = 0;
|
|
test_string = "";
|
|
for ( ;; )
|
|
{
|
|
while ( 1 )
|
|
{
|
|
if ( level.camera_snapto > 0 )
|
|
{
|
|
if ( level.stick_camera )
|
|
{
|
|
originoffset = vectorScale( level.cameravec, -1 );
|
|
temp_offset = originoffset + vectorScale( ( 1, 1, 1 ), 60 );
|
|
anglesoffset = vectorToAngle( temp_offset );
|
|
if ( level.camera_prev_snapto == level.camera_snapto )
|
|
{
|
|
players = get_players();
|
|
newmovement = players[ 0 ] getnormalizedmovement();
|
|
dolly_movement = players[ 0 ] getnormalizedcameramovement();
|
|
if ( button_is_held( "BUTTON_LTRIG" ) || button_is_held( "BUTTON_RTRIG" ) )
|
|
{
|
|
}
|
|
else
|
|
{
|
|
if ( newmovement[ 1 ] <= -0,4 )
|
|
{
|
|
n_y_vector += -0,2;
|
|
b_changes_y = 1;
|
|
}
|
|
else if ( newmovement[ 1 ] >= 0,4 )
|
|
{
|
|
n_y_vector += 0,2;
|
|
b_changes_y = 1;
|
|
}
|
|
else
|
|
{
|
|
b_changes_y = 0;
|
|
}
|
|
if ( newmovement[ 0 ] <= -0,4 )
|
|
{
|
|
n_x_vector += -0,4;
|
|
b_changes_x = 1;
|
|
}
|
|
else if ( newmovement[ 0 ] >= 0,4 )
|
|
{
|
|
n_x_vector += 0,4;
|
|
b_changes_x = 1;
|
|
}
|
|
else
|
|
{
|
|
b_changes_x = 0;
|
|
}
|
|
if ( dolly_movement[ 0 ] <= -0,4 )
|
|
{
|
|
zoom_level += 30;
|
|
b_changes_z = 1;
|
|
}
|
|
else if ( dolly_movement[ 0 ] >= 0,4 )
|
|
{
|
|
zoom_level += -30;
|
|
b_changes_z = 1;
|
|
}
|
|
else
|
|
{
|
|
b_changes_z = 0;
|
|
}
|
|
if ( !b_changes_z || b_changes_x && b_changes_y )
|
|
{
|
|
newmovement = ( n_x_vector, n_y_vector, newmovement[ 2 ] );
|
|
movement = ( 1, 1, 1 );
|
|
movement = vectorScale( movement, 0,8 ) + vectorScale( newmovement, 1 - 0,8 );
|
|
tilt = max( 0, 10 + ( movement[ 0 ] * 160 ) );
|
|
level.cameravec = ( cos( movement[ 1 ] * 180 ) * zoom_level, sin( movement[ 1 ] * 180 ) * zoom_level, tilt );
|
|
iprintln( level.cameravec[ 0 ] + " " + level.cameravec[ 1 ] + " " + level.cameravec[ 2 ] );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
level.camera_prev_snapto = level.camera_snapto;
|
|
}
|
|
if ( isDefined( level.current_select_ent ) )
|
|
{
|
|
originoffset = vectorScale( level.cameravec, -1 );
|
|
temp_offset = originoffset + vectorScale( ( 1, 1, 1 ), 60 );
|
|
anglesoffset = vectorToAngle( temp_offset );
|
|
if ( !isDefined( model ) )
|
|
{
|
|
model = spawn( "script_origin", level.current_select_ent.v[ "origin" ] );
|
|
model setmodel( "tag_origin" );
|
|
}
|
|
if ( model.origin != level.current_select_ent.v[ "origin" ] )
|
|
{
|
|
model.origin = level.current_select_ent.v[ "origin" ];
|
|
}
|
|
level.camera linkto( model, "tag_origin", level.cameravec, anglesoffset );
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
wait 0,05;
|
|
}
|
|
}
|
|
}
|
|
else level.camera unlink();
|
|
}
|
|
wait 0,05;
|
|
#/
|
|
}
|
|
}
|
|
|
|
camera_hud_toggle( text )
|
|
{
|
|
if ( isDefined( level.camera_hud ) )
|
|
{
|
|
level.camera_hud destroy();
|
|
}
|
|
level.camera_hud = newdebughudelem();
|
|
level.camera_hud settext( text );
|
|
level.camera_hud.horzalign = "left";
|
|
level.camera_hud.vertalign = "bottom";
|
|
level.camera_hud.alignx = "left";
|
|
level.camera_hud.aligny = "bottom";
|
|
level.camera_hud.foreground = 1;
|
|
level.camera_hud.fontscale = 1,1;
|
|
level.camera_hud.sort = 21;
|
|
level.camera_hud.alpha = 1;
|
|
level.camera_hud.color = ( 1, 1, 1 );
|
|
}
|
|
|
|
init_sp_paths()
|
|
{
|
|
}
|
|
|
|
make_sp_player_invulnerable( player )
|
|
{
|
|
}
|
|
|
|
delete_arrays_in_sp()
|
|
{
|
|
}
|
|
|
|
used_in_animation( sp )
|
|
{
|
|
}
|
|
|
|
init_client_sp_variables()
|
|
{
|
|
}
|
|
|
|
init_mp_paths()
|
|
{
|
|
level.cfx_server_scriptdata = "mpcreatefx/";
|
|
level.cfx_client_scriptdata = "mpclientcreatefx/";
|
|
level.cfx_server_loop = "maps\\mp\\_utility::createLoopEffect";
|
|
level.cfx_server_oneshot = "maps\\mp\\_utility::createOneshotEffect";
|
|
level.cfx_server_exploder = "maps\\mp\\_utility::createExploder";
|
|
level.cfx_server_loopsound = "maps\\mp\\_createfx::createLoopSound";
|
|
level.cfx_server_scriptgendump = "maps\\mp\\createfx\\" + level.script + "_fx::main();";
|
|
level.cfx_client_loop = "clientscripts\\mp\\_fx::createLoopEffect";
|
|
level.cfx_client_oneshot = "clientscripts\\mp\\_fx::createOneshotEffect";
|
|
level.cfx_client_exploder = "clientscripts\\mp\\_fx::createExploder";
|
|
level.cfx_client_loopsound = "clientscripts\\mp\\_fx::createLoopSound";
|
|
level.cfx_client_scriptgendump = "clientscripts\\mp\\_createfx\\" + level.script + "_fx::main();";
|
|
level.cfx_func_run_gump_func = ::empty;
|
|
level.cfx_func_loopfx = ::maps/mp/_fx::loopfxthread;
|
|
level.cfx_func_oneshotfx = ::maps/mp/_fx::oneshotfxthread;
|
|
level.cfx_func_soundfx = ::maps/mp/_fx::create_loopsound;
|
|
level.cfx_func_script_gen_dump = ::maps/mp/_script_gen::script_gen_dump;
|
|
level.cfx_func_stop_loopsound = ::maps/mp/_fx::stop_loopsound;
|
|
level.cfx_func_create_looper = ::maps/mp/_fx::create_looper;
|
|
level.cfx_func_create_triggerfx = ::maps/mp/_fx::create_triggerfx;
|
|
level.cfx_func_create_loopsound = ::maps/mp/_fx::create_loopsound;
|
|
}
|
|
|
|
callback_playerconnect()
|
|
{
|
|
self waittill( "begin" );
|
|
if ( !isDefined( level.hasspawned ) )
|
|
{
|
|
spawnpoints = getentarray( "mp_global_intermission", "classname" );
|
|
if ( !spawnpoints.size )
|
|
{
|
|
spawnpoints = getentarray( "info_player_start", "classname" );
|
|
}
|
|
/#
|
|
assert( spawnpoints.size );
|
|
#/
|
|
spawnpoint = spawnpoints[ 0 ];
|
|
self.sessionteam = "none";
|
|
self.sessionstate = "playing";
|
|
if ( !level.teambased )
|
|
{
|
|
self.ffateam = "none";
|
|
}
|
|
self spawn( spawnpoint.origin, spawnpoint.angles );
|
|
level.player = self;
|
|
level.hasspawned = 1;
|
|
}
|
|
else
|
|
{
|
|
kick( self.name );
|
|
}
|
|
}
|
|
|
|
delete_spawns()
|
|
{
|
|
spawn_classes = [];
|
|
spawn_classes[ spawn_classes.size ] = "mp_dm_spawn";
|
|
spawn_classes[ spawn_classes.size ] = "mp_tdm_spawn";
|
|
spawn_classes[ spawn_classes.size ] = "mp_dom_spawn";
|
|
spawn_classes[ spawn_classes.size ] = "mp_dom_spawn_axis_start";
|
|
spawn_classes[ spawn_classes.size ] = "mp_dom_spawn_allies_start";
|
|
spawn_classes[ spawn_classes.size ] = "mp_res_spawn_allies";
|
|
spawn_classes[ spawn_classes.size ] = "mp_res_spawn_axis";
|
|
spawn_classes[ spawn_classes.size ] = "mp_res_spawn_axis_start";
|
|
spawn_classes[ spawn_classes.size ] = "mp_dem_spawn_attacker";
|
|
spawn_classes[ spawn_classes.size ] = "mp_dem_spawn_attacker_a";
|
|
spawn_classes[ spawn_classes.size ] = "mp_dem_spawn_attacker_b";
|
|
spawn_classes[ spawn_classes.size ] = "mp_dem_spawn_attacker_c";
|
|
spawn_classes[ spawn_classes.size ] = "mp_dem_spawn_attacker_start";
|
|
spawn_classes[ spawn_classes.size ] = "mp_dem_spawn_attackerOT_start";
|
|
spawn_classes[ spawn_classes.size ] = "mp_dem_spawn_defender";
|
|
spawn_classes[ spawn_classes.size ] = "mp_dem_spawn_defender_a";
|
|
spawn_classes[ spawn_classes.size ] = "mp_dem_spawn_defender_b";
|
|
spawn_classes[ spawn_classes.size ] = "mp_dem_spawn_defender_c";
|
|
spawn_classes[ spawn_classes.size ] = "mp_dem_spawn_defender_start";
|
|
spawn_classes[ spawn_classes.size ] = "mp_dem_spawn_defenderOT_start";
|
|
_a4256 = spawn_classes;
|
|
_k4256 = getFirstArrayKey( _a4256 );
|
|
while ( isDefined( _k4256 ) )
|
|
{
|
|
class = _a4256[ _k4256 ];
|
|
spawns = getentarray( class, "classname" );
|
|
_a4260 = spawns;
|
|
_k4260 = getFirstArrayKey( _a4260 );
|
|
while ( isDefined( _k4260 ) )
|
|
{
|
|
spawn = _a4260[ _k4260 ];
|
|
spawn delete();
|
|
_k4260 = getNextArrayKey( _a4260, _k4260 );
|
|
}
|
|
_k4256 = getNextArrayKey( _a4256, _k4256 );
|
|
}
|
|
}
|
|
|
|
createfxdelay()
|
|
{
|
|
wait 10;
|
|
level.createfx_delay_done = 1;
|
|
}
|
|
|
|
init_client_mp_variables()
|
|
{
|
|
level.cfx_exploder_before = ::maps/mp/_utility::exploder_before_load;
|
|
level.cfx_exploder_after = ::maps/mp/_utility::exploder_after_load;
|
|
}
|