mirror of
https://github.com/InfinityLoader/IL-GSC.git
synced 2025-06-10 02:17:56 -05:00
644 lines
19 KiB
Plaintext
644 lines
19 KiB
Plaintext
#include clientscripts\_utility;
|
||
deactivateAmbientPackage(client, package, priority)
|
||
{
|
||
if ( !isdefined( level.ambientPackages[package] ) )
|
||
{
|
||
assertmsg( "deactivateAmbientPackage: must declare ambient package \"" + package + "\" in level_amb main before it can be deactivated" );
|
||
return;
|
||
}
|
||
for( i = 0; i < level.ambientPackages[package].priority.size; i++)
|
||
{
|
||
if ( level.ambientPackages[package].priority[i] == priority && level.ambientPackages[package].refcount[i] )
|
||
{
|
||
level.ambientPackages[package].refcount[i]--;
|
||
level notify( "updateActiveAmbientPackage" );
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
deactivateAmbientRoom(client, room, priority)
|
||
{
|
||
if ( !isdefined( level.ambientRooms[room] ) )
|
||
{
|
||
assertmsg( "deactivateAmbientRoom: must declare ambient room \"" + room + "\" in level_amb main before it can be deactivated" );
|
||
return;
|
||
}
|
||
for( i = 0; i < level.ambientRooms[room].priority.size; i++ )
|
||
{
|
||
if( level.ambientRooms[room].priority[i] == priority && level.ambientRooms[room].refcount[i] )
|
||
{
|
||
level.ambientRooms[room].refcount[i]--;
|
||
level notify( "updateActiveAmbientRoom" );
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
trig_enter(ent)
|
||
{
|
||
if( self.useAmbientPackage )
|
||
activateAmbientPackage( 0, self.script_ambientpackage, self.script_ambientpriority);
|
||
if( self.useAmbientRoom )
|
||
activateAmbientRoom( 0, self.script_ambientroom, self.script_ambientpriority );
|
||
}
|
||
trig_leave(ent)
|
||
{
|
||
if( self.useAmbientPackage )
|
||
deactivateAmbientPackage( 0, self.script_ambientpackage, self.script_ambientpriority );
|
||
if( self.useAmbientRoom )
|
||
deactivateAmbientRoom( 0, self.script_ambientroom, self.script_ambientpriority );
|
||
}
|
||
AmbientPackageTrigger()
|
||
{
|
||
hasAmbientRoom = isdefined ( self.script_ambientroom );
|
||
useAmbientRoom = hasAmbientRoom && isdefined( level.ambientRooms[self.script_ambientroom] );
|
||
hasAmbientPackage = isdefined ( self.script_ambientpackage );
|
||
useAmbientPackage = hasAmbientPackage && isdefined( level.ambientPackages[self.script_ambientpackage] );
|
||
self.useAmbientRoom = useAmbientRoom;
|
||
self.useAmbientPackage = useAmbientPackage;
|
||
if (hasAmbientRoom && !useAmbientRoom)
|
||
{
|
||
assertmsg( "Trigger at " + self.origin + " references ambient room '" + self.script_ambientroom + "', but no such room has been declared\n" );
|
||
return;
|
||
}
|
||
if (hasAmbientPackage && !useAmbientPackage)
|
||
{
|
||
assertmsg( "Trigger at " + self.origin + " references ambient package '" + self.script_ambientpackage + "', but no such package has been declared\n" );
|
||
return;
|
||
}
|
||
if(!useAmbientPackage && !useAmbientRoom)
|
||
{
|
||
assertmsg( "Trigger at " + self.origin + " is an ambient trigger but has no room or package \n" );
|
||
return;
|
||
}
|
||
if ( !isdefined( self.script_ambientpriority ) )
|
||
{
|
||
self.script_ambientpriority = 1;
|
||
}
|
||
self.in_volume = [];
|
||
for (;;)
|
||
{
|
||
self waittill ( "trigger", trigPlayer );
|
||
if(trigPlayer issplitscreenhost())
|
||
{
|
||
self thread trigger_thread(trigPlayer, ::trig_enter, ::trig_leave);
|
||
}
|
||
wait(0.01);
|
||
}
|
||
}
|
||
init_ambient_package_triggers()
|
||
{
|
||
wait(0.1);
|
||
player = GetLocalPlayers()[0];
|
||
remove_triggers_from_ent( player );
|
||
trigs = GetEntArray( 0, "ambient_package","targetname");
|
||
array_thread( trigs, ::ambientPackageTrigger);
|
||
println("Client : " + trigs.size + " ambient package triggers.");
|
||
}
|
||
init()
|
||
{
|
||
level.activeAmbientPackage = "";
|
||
level.ambientPackages = [];
|
||
level.ambientNumMissedSounds = 0;
|
||
level.ambientNumSeqMissedSounds = 0;
|
||
thread updateActiveAmbientPackage();
|
||
thread saveRestore();
|
||
level.ambientPackageScriptOriginPool = [];
|
||
for ( i = 0; i < 5; i++ )
|
||
{
|
||
level.ambientPackageScriptOriginPool[i] = spawnStruct();
|
||
level.ambientPackageScriptOriginPool[i].org = spawnfakeent(0);
|
||
level.ambientPackageScriptOriginPool[i].inuse = false;
|
||
level.ambientPackageScriptOriginPool[i] thread scriptOriginPoolThread();
|
||
}
|
||
level.activeAmbientRoom = "";
|
||
level.ambientRooms = [];
|
||
level thread updateActiveAmbientRoom();
|
||
clientscripts\_utility::registerSystem("ambientPackageCmd", ::ambientPackageCmdHandler);
|
||
clientscripts\_utility::registerSystem("ambientRoomCmd", ::ambientRoomCmdHandler);
|
||
level thread init_ambient_package_triggers();
|
||
}
|
||
declareAmbientPackage( package )
|
||
{
|
||
if ( isdefined( level.ambientPackages[package] ) )
|
||
return;
|
||
level.ambientPackages[package] = spawnStruct();
|
||
level.ambientPackages[package].priority = [];
|
||
level.ambientPackages[package].refcount = [];
|
||
level.ambientPackages[package].elements = [];
|
||
}
|
||
addAmbientElement( package, alias, spawnMin, spawnMax, distMin, distMax, angleMin, angleMax )
|
||
{
|
||
if ( !isdefined( level.ambientPackages[package] ) )
|
||
{
|
||
assertmsg( "addAmbientElement: must declare ambient package \"" + package + "\" in level_amb main before it can have elements added to it" );
|
||
return;
|
||
}
|
||
index = level.ambientPackages[package].elements.size;
|
||
level.ambientPackages[package].elements[index] = spawnStruct();
|
||
level.ambientPackages[package].elements[index].alias = alias;
|
||
if ( spawnMin < 0 )
|
||
spawnMin = 0;
|
||
if ( spawnMin >= spawnMax )
|
||
spawnMax = spawnMin + 1;
|
||
level.ambientPackages[package].elements[index].spawnMin = spawnMin;
|
||
level.ambientPackages[package].elements[index].spawnMax = spawnMax;
|
||
level.ambientPackages[package].elements[index].distMin = -1;
|
||
level.ambientPackages[package].elements[index].distMax = -1;
|
||
if ( isdefined( distMin ) && isdefined( distMax ) && distMin >= 0 && distMin < distMax )
|
||
{
|
||
level.ambientPackages[package].elements[index].distMin = distMin;
|
||
level.ambientPackages[package].elements[index].distMax = distMax;
|
||
}
|
||
level.ambientPackages[package].elements[index].angleMin = 0;
|
||
level.ambientPackages[package].elements[index].angleMax = 359;
|
||
if ( isdefined( angleMin ) && isdefined( angleMax ) && angleMin >= 0 && angleMin < angleMax && angleMax <= 720 )
|
||
{
|
||
level.ambientPackages[package].elements[index].angleMin = angleMin;
|
||
level.ambientPackages[package].elements[index].angleMax = angleMax;
|
||
}
|
||
}
|
||
declareAmbientRoom( room )
|
||
{
|
||
if ( isdefined( level.ambientRooms[room] ) )
|
||
return;
|
||
level.ambientRooms[room] = spawnStruct();
|
||
level.ambientRooms[room].priority = [];
|
||
level.ambientRooms[room].refcount = [];
|
||
level.ambientRooms[room].ent = spawnfakeent(0);
|
||
}
|
||
setAmbientRoomTone( room, alias, fadeIn, fadeOut )
|
||
{
|
||
if ( !isdefined( level.ambientRooms[room] ) )
|
||
{
|
||
assertmsg( "setAmbientRoomTone: must declare ambient room \"" + room + "\" in level_amb main before it can have a room tone set" );
|
||
return;
|
||
}
|
||
level.ambientRooms[room].tone = alias;
|
||
level.ambientRooms[room].fadeIn = 2;
|
||
if ( isDefined( fadeIn ) && fadeIn >= 0 )
|
||
{
|
||
level.ambientRooms[room].fadeIn = fadeIn;
|
||
}
|
||
level.ambientRooms[room].fadeOut = 2;
|
||
if ( isDefined( fadeOut ) && fadeOut >= 0 )
|
||
{
|
||
level.ambientRooms[room].fadeOut = fadeOut;
|
||
}
|
||
}
|
||
setAmbientRoomSnapshot( room, snapshot)
|
||
{
|
||
if ( !isdefined( level.ambientRooms[room] ) )
|
||
{
|
||
assertmsg( "setAmbientRoomSnapshot: must declare ambient room \"" + room + "\" in level_amb main before it can have a room snapshot set" );
|
||
return;
|
||
}
|
||
level.ambientRooms[room].snapshot = snapshot;
|
||
}
|
||
setAmbientRoomContext( room, type, value)
|
||
{
|
||
if ( !isdefined( level.ambientRooms[room] ) )
|
||
{
|
||
assertmsg( "setAmbientRoomContext: must declare ambient room \"" + room + "\" in level_amb main before it can have a room context set" );
|
||
return;
|
||
}
|
||
if(!isdefined(level.ambientRooms[room].context))
|
||
{
|
||
level.ambientRooms[room].context = [];
|
||
}
|
||
level.ambientRooms[room].context[type] = value;
|
||
if(!isdefined(level.ambientContexts))
|
||
{
|
||
level.ambientContexts = [];
|
||
}
|
||
level.ambientContexts[type] = type;
|
||
}
|
||
setAmbientRoomReverb( room, reverbRoomType, dry, wet, fade )
|
||
{
|
||
if ( !isdefined( level.ambientRooms[room] ) )
|
||
{
|
||
assertmsg( "setAmbientRoomReverb: must declare ambient room \"" + room + "\" in level_amb main before it can have a room reverb set" );
|
||
return;
|
||
}
|
||
level.ambientRooms[room].reverb = spawnStruct();
|
||
level.ambientRooms[room].reverb.reverbRoomType = reverbRoomType;
|
||
level.ambientRooms[room].reverb.dry = dry;
|
||
level.ambientRooms[room].reverb.wet = wet;
|
||
level.ambientRooms[room].reverb.fade = 2;
|
||
if ( isDefined( fade ) && fade >= 0 )
|
||
{
|
||
level.ambientRooms[room].reverb.fade = fade;
|
||
}
|
||
}
|
||
activateAmbientPackage( clientNum, package, priority )
|
||
{
|
||
if ( !isdefined( level.ambientPackages[package] ) )
|
||
{
|
||
assertmsg( "activateAmbientPackage: must declare ambient package \"" + package + "\" in level_amb.csc main before it can be activated" );
|
||
return;
|
||
}
|
||
for ( i = 0; i < level.ambientPackages[package].priority.size; i++ )
|
||
{
|
||
if ( level.ambientPackages[package].priority[i] == priority )
|
||
{
|
||
level.ambientPackages[package].refcount[i]++;
|
||
break;
|
||
}
|
||
}
|
||
if ( i == level.ambientPackages[package].priority.size )
|
||
{
|
||
level.ambientPackages[package].priority[i] = priority;
|
||
level.ambientPackages[package].refcount[i] = 1;
|
||
}
|
||
level notify( "updateActiveAmbientPackage" );
|
||
}
|
||
activateAmbientRoom( clientNum, room, priority )
|
||
{
|
||
if ( !isdefined( level.ambientRooms[room] ) )
|
||
{
|
||
assertmsg( "activateAmbientRoom: must declare ambient room \"" + room + "\" in level_amb.csc main before it can be activated" );
|
||
return;
|
||
}
|
||
for ( i = 0; i < level.ambientRooms[room].priority.size; i++ )
|
||
{
|
||
if ( level.ambientRooms[room].priority[i] == priority )
|
||
{
|
||
level.ambientRooms[room].refcount[i]++;
|
||
break;
|
||
}
|
||
}
|
||
if ( i == level.ambientRooms[room].priority.size )
|
||
{
|
||
level.ambientRooms[room].priority[i] = priority;
|
||
level.ambientRooms[room].refcount[i] = 1;
|
||
}
|
||
level notify( "updateActiveAmbientRoom" );
|
||
}
|
||
ambientPackageCmdHandler(clientNum, state, oldState)
|
||
{
|
||
if(state != "")
|
||
{
|
||
split_state = splitargs(state);
|
||
if(split_state.size != 3)
|
||
{
|
||
println("*** Client : Malformed arguements to ambient packages " + state);
|
||
}
|
||
else
|
||
{
|
||
command = split_state[0];
|
||
package = split_state[1];
|
||
priority = int(split_state[2]);
|
||
println("### APC : " + command + " " + package + " " + priority);
|
||
if(command == "A")
|
||
{
|
||
if ( !isdefined( level.ambientPackages[package] ) )
|
||
{
|
||
assertmsg( "activateAmbientPackage: must declare ambient package \"" + package + "\" in level_amb.csc main before it can be activated" );
|
||
return;
|
||
}
|
||
for ( i = 0; i < level.ambientPackages[package].priority.size; i++ )
|
||
{
|
||
if ( level.ambientPackages[package].priority[i] == priority )
|
||
{
|
||
level.ambientPackages[package].refcount[i]++;
|
||
break;
|
||
}
|
||
}
|
||
if ( i == level.ambientPackages[package].priority.size )
|
||
{
|
||
level.ambientPackages[package].priority[i] = priority;
|
||
level.ambientPackages[package].refcount[i] = 1;
|
||
}
|
||
level notify( "updateActiveAmbientPackage" );
|
||
}
|
||
else if(command == "D")
|
||
{
|
||
if ( !isdefined( level.ambientPackages[package] ) )
|
||
{
|
||
assertmsg( "deactivateAmbientPackage: must declare ambient package \"" + package + "\" in level_amb.csc main before it can be deactivated" );
|
||
return;
|
||
}
|
||
for ( i = 0; i < level.ambientPackages[package].priority.size; i++ )
|
||
{
|
||
if ( level.ambientPackages[package].priority[i] == priority && level.ambientPackages[package].refcount[i] )
|
||
{
|
||
level.ambientPackages[package].refcount[i]--;
|
||
level notify( "updateActiveAmbientPackage" );
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
assertmsg("Unknown command in ambientPackageCmdHandler " + state);
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
ambientRoomCmdHandler(clientNum, state, oldState)
|
||
{
|
||
if(state != "")
|
||
{
|
||
split_state = splitargs(state);
|
||
if(split_state.size != 3)
|
||
{
|
||
println("*** Client : Malformed arguements to ambient packages " + state);
|
||
}
|
||
else
|
||
{
|
||
command = split_state[0];
|
||
room = split_state[1];
|
||
priority = int(split_state[2]);
|
||
if(command == "A")
|
||
{
|
||
if ( !isdefined( level.ambientRooms[room] ) )
|
||
{
|
||
assertmsg( "activateAmbientRoom: must declare ambient room \"" + room + "\" in level_amb.csc main before it can be activated" );
|
||
return;
|
||
}
|
||
for ( i = 0; i < level.ambientRooms[room].priority.size; i++ )
|
||
{
|
||
if ( level.ambientRooms[room].priority[i] == priority )
|
||
{
|
||
level.ambientRooms[room].refcount[i]++;
|
||
break;
|
||
}
|
||
}
|
||
if ( i == level.ambientRooms[room].priority.size )
|
||
{
|
||
level.ambientRooms[room].priority[i] = priority;
|
||
level.ambientRooms[room].refcount[i] = 1;
|
||
}
|
||
level notify( "updateActiveAmbientRoom" );
|
||
}
|
||
else if(command == "D")
|
||
{
|
||
if ( !isdefined( level.ambientRooms[room] ) )
|
||
{
|
||
assertmsg( "deactivateAmbientRoom: must declare ambient room \"" + room + "\" in level_amb.csc main before it can be deactivated" );
|
||
return;
|
||
}
|
||
for ( i = 0; i < level.ambientRooms[room].priority.size; i++ )
|
||
{
|
||
if ( level.ambientRooms[room].priority[i] == priority && level.ambientRooms[room].refcount[i] )
|
||
{
|
||
level.ambientRooms[room].refcount[i]--;
|
||
level notify( "updateActiveAmbientRoom" );
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
else
|
||
{
|
||
assertmsg("Unknown command in ambientRoomCmdHandler " + state);
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
ambientElementThread()
|
||
{
|
||
level endon( "killambientElementThread" + level.activeAmbientPackage );
|
||
timer = 0;
|
||
if ( self.distMin < 0 )
|
||
{
|
||
for (;;)
|
||
{
|
||
timer = randomfloatrange( self.spawnMin, self.spawnMax );
|
||
wait timer;
|
||
if( getdvarint( #"debug_audio" ) > 0 )
|
||
{
|
||
}
|
||
playsound( 0, self.alias );
|
||
}
|
||
}
|
||
else
|
||
{
|
||
dist = 0;
|
||
angle = 0;
|
||
offset = (0, 0, 0);
|
||
index = -1;
|
||
for (;;)
|
||
{
|
||
timer = randomfloatrange( self.spawnMin, self.spawnMax );
|
||
wait timer;
|
||
index = getScriptOriginPoolIndex();
|
||
if ( index >= 0 )
|
||
{
|
||
dist = randomintrange( self.distMin, self.distMax );
|
||
angle = randomintrange( self.angleMin, self.angleMax );
|
||
player_angle = getlocalclientangles(0)[1];
|
||
offset = anglestoforward( ( 0, angle + player_angle, 0 ) );
|
||
offset = vector_scale( offset, dist );
|
||
pos = getlocalclienteyepos(0) + offset;
|
||
setfakeentorg(0, level.ambientPackageScriptOriginPool[index].org, pos);
|
||
level.ambientPackageScriptOriginPool[index].soundId = playSound( 0, self.alias, pos );
|
||
if( getdvarint( #"debug_audio" ) > 0 )
|
||
{
|
||
if(level.ambientPackageScriptOriginPool[index].soundId == -1)
|
||
{
|
||
col = (0.8, 0.0, 0.0);
|
||
}
|
||
else
|
||
{
|
||
col = (0.0, 0.8, 0.0);
|
||
}
|
||
print3d (pos, "AP : " + self.alias, col, 1, 3, 30);
|
||
}
|
||
while(level.ambientPackageScriptOriginPool[index].soundId != -1)
|
||
{
|
||
wait(0.01);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
getScriptOriginPoolIndex()
|
||
{
|
||
for ( index = 0; index < level.ambientPackageScriptOriginPool.size; index++ )
|
||
{
|
||
if ( !level.ambientPackageScriptOriginPool[index].inuse )
|
||
{
|
||
level.ambientPackageScriptOriginPool[index].inuse = true;
|
||
level.ambientNumSeqMissedSounds = 0;
|
||
return index;
|
||
}
|
||
}
|
||
level.ambientNumMissedSounds++;
|
||
level.ambientNumSeqMissedSounds++;
|
||
if( getdvarint( #"debug_audio" ) > 0 )
|
||
{
|
||
}
|
||
return -1;
|
||
}
|
||
scriptOriginPoolThread()
|
||
{
|
||
for (;;)
|
||
{
|
||
if(self.inuse == true)
|
||
{
|
||
if(isdefined(self.soundId))
|
||
{
|
||
if(self.SoundId != -1)
|
||
{
|
||
if(!SoundPlaying(self.soundId))
|
||
{
|
||
self.inuse = false;
|
||
self.soundId = -1;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
self.inUse = false;
|
||
}
|
||
}
|
||
}
|
||
wait(0.01);
|
||
}
|
||
}
|
||
findHighestPriorityAmbientPackage()
|
||
{
|
||
package = "";
|
||
priority = -1;
|
||
packageArray = getArrayKeys( level.ambientPackages );
|
||
for ( i = 0; i < packageArray.size; i++ )
|
||
{
|
||
for ( j = 0; j < level.ambientPackages[packageArray[i]].priority.size; j++ )
|
||
{
|
||
if ( level.ambientPackages[packageArray[i]].refcount[j] && level.ambientPackages[packageArray[i]].priority[j] > priority )
|
||
{
|
||
package = packageArray[i];
|
||
priority = level.ambientPackages[packageArray[i]].priority[j];
|
||
}
|
||
}
|
||
}
|
||
return package;
|
||
}
|
||
updateActiveAmbientPackage()
|
||
{
|
||
for (;;)
|
||
{
|
||
level waittill( "updateActiveAmbientPackage" );
|
||
newAmbientPackage = findHighestPriorityAmbientPackage();
|
||
println("*** nap " + newAmbientPackage + " " + level.activeAmbientPackage);
|
||
if ( newAmbientPackage != "" && level.activeAmbientPackage != newAmbientPackage )
|
||
{
|
||
level notify( "killambientElementThread" + level.activeAmbientPackage );
|
||
level.activeAmbientPackage = newAmbientPackage;
|
||
array_thread( level.ambientPackages[level.activeAmbientPackage].elements, ::ambientElementThread );
|
||
}
|
||
}
|
||
}
|
||
roomToneFadeOutTimerThread( fadeOut )
|
||
{
|
||
self endon( "killRoomToneFadeOutTimer" );
|
||
wait fadeOut;
|
||
self.inuse = false;
|
||
}
|
||
findHighestPriorityAmbientRoom()
|
||
{
|
||
room = "";
|
||
priority = -1;
|
||
roomArray = getArrayKeys( level.ambientRooms );
|
||
if(isdefined(roomArray))
|
||
{
|
||
for ( i = 0; i < roomArray.size; i++ )
|
||
{
|
||
for ( j = 0; j < level.ambientRooms[roomArray[i]].priority.size; j++ )
|
||
{
|
||
if ( level.ambientRooms[roomArray[i]].refcount[j] )
|
||
{
|
||
}
|
||
if ( level.ambientRooms[roomArray[i]].refcount[j] && level.ambientRooms[roomArray[i]].priority[j] > priority )
|
||
{
|
||
room = roomArray[i];
|
||
priority = level.ambientRooms[roomArray[i]].priority[j];
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return room;
|
||
}
|
||
saveRestore()
|
||
{
|
||
for(;;)
|
||
{
|
||
level waittill("save_restore");
|
||
level.activeAmbientRoom = "";
|
||
level notify( "updateActiveAmbientRoom" );
|
||
}
|
||
}
|
||
updateActiveAmbientRoom()
|
||
{
|
||
for (;;)
|
||
{
|
||
newAmbientRoom = findHighestPriorityAmbientRoom();
|
||
if(newAmbientRoom == level.activeAmbientRoom)
|
||
{
|
||
level waittill( "updateActiveAmbientRoom" );
|
||
}
|
||
if(newAmbientRoom == level.activeAmbientRoom)
|
||
{
|
||
continue;
|
||
}
|
||
oldroom = level.ambientRooms[level.activeAmbientRoom];
|
||
newroom = level.ambientRooms[newAmbientRoom];
|
||
if(isdefined(oldroom) && isdefined(newroom)
|
||
&& isdefined(oldroom.tone) && isdefined(newroom.tone)
|
||
&& oldroom.tone == newroom.tone)
|
||
{
|
||
tmp = newroom.ent;
|
||
newroom.ent = oldroom.ent;
|
||
oldroom.ent = tmp;
|
||
}
|
||
else
|
||
{
|
||
if(isdefined(newroom) && isdefined(newroom.tone))
|
||
{
|
||
newroom.id = playloopsound( 0, newroom.ent, newroom.tone, newroom.fadeIn );
|
||
}
|
||
else
|
||
{
|
||
}
|
||
if(isdefined(oldroom) && isdefined(oldroom.tone))
|
||
{
|
||
stoploopsound(0, oldroom.ent, oldroom.fadeOut);
|
||
}
|
||
else
|
||
{
|
||
}
|
||
}
|
||
if ( !isdefined( newroom ) || !isdefined( newroom.reverb ) )
|
||
{
|
||
deactivateReverb( "snd_enveffectsprio_level", 2 );
|
||
}
|
||
else
|
||
{
|
||
setReverb( "snd_enveffectsprio_level", newroom.reverb.reverbRoomType, newroom.reverb.dry, newroom.reverb.wet, newroom.reverb.fade );
|
||
}
|
||
snapshot = "default";
|
||
if( isdefined( newroom ) && isdefined( newroom.snapshot ) )
|
||
{
|
||
snapshot = newroom.snapshot;
|
||
}
|
||
setAmbientSnapshot(snapshot);
|
||
if(isdefined(newroom) && isdefined(level.ambientContexts))
|
||
{
|
||
contexts = getArrayKeys(level.ambientContexts);
|
||
for(i=0; i<contexts.size; i++)
|
||
{
|
||
setsoundcontext( contexts[i], "");
|
||
}
|
||
if( isdefined( newroom.context ) )
|
||
{
|
||
keys = getArrayKeys(newroom.context);
|
||
for(i=0; i<keys.size; i++)
|
||
{
|
||
setsoundcontext( keys[i], newroom.context[ keys[i]]);
|
||
}
|
||
}
|
||
}
|
||
level.activeAmbientRoom = newAmbientRoom;
|
||
}
|
||
}
|
||
|
||
|