449 lines
16 KiB
C++
449 lines
16 KiB
C++
/*
|
|
* ambience.cpp
|
|
|
|
*
|
|
* Created on: Jun 13, 2015
|
|
* Author: brandon
|
|
*/
|
|
|
|
#include "ambiance.h"
|
|
#include "log.h"
|
|
#include "localplayer.h"
|
|
#include "map.h"
|
|
#include "clientmap.h"
|
|
|
|
const std::string DIRT = "default:dirt";//m_env.getGameDef()->getNodeDefManager()->getId("default:dirt");
|
|
const std::string STONE = "default:stone";//m_env.getGameDef()->getNodeDefManager()->getId("default:stone");
|
|
const std::string GRASS = "default:dirt_with_grass";//m_env.getGameDef()->getNodeDefManager()->getId("default:dirt_with_grass");
|
|
const std::string TREE = "default:tree";//m_env.getGameDef()->getNodeDefManager()->getId("default:tree");
|
|
const std::string LEAVES = "default:leaves";//m_env.getGameDef()->getNodeDefManager()->getId("default:leaves");
|
|
const std::string WATER = "default:water_source";//m_env.getGameDef()->getNodeDefManager()->getId("default:water_source");
|
|
const std::string WATER_FLOWING = "default:water_flowing";//m_env.getGameDef()->getNodeDefManager()->getId("default:water_flowing");
|
|
const std::string MG_WATER = "default:mg_water_source";
|
|
const std::string MG_WATER_FLOWING = "default:mg_water_flowing";
|
|
const std::string SNOW = "default:snow";
|
|
const std::string DIRT_SNOW = "default:dirt_with_snow";
|
|
const std::string SAND = "default:sand";
|
|
const std::string DESERT_STONE = "default:desert_stone";
|
|
const std::string DESERT_SAND = "default:desert_sand";
|
|
const std::string JUNGLE_TREE = "default:jungletree";
|
|
const std::string JUNGLE_LEAVES = "default:jungleleaves";
|
|
const std::string JUNGLE_GRASS = "default:junglegrass";
|
|
|
|
Ambiance::Ambiance(ISoundManager *sound, ClientEnvironment &e):
|
|
m_sound(sound),
|
|
m_env(e),
|
|
currentEnv(0)
|
|
{
|
|
verbosestream << "[AMBIANCE] Loading sound files...";
|
|
m_sound->loadSoundFile("bats","client/sounds/bats.ogg");
|
|
m_sound->loadSoundFile("bird","client/sounds/bird.ogg");
|
|
m_sound->loadSoundFile("bird2","client/sounds/bird2.ogg");
|
|
m_sound->loadSoundFile("bird3","client/sounds/bird3.ogg");
|
|
m_sound->loadSoundFile("bird4","client/sounds/bird4.ogg");
|
|
m_sound->loadSoundFile("birdsong","client/sounds/birdsong.ogg");
|
|
m_sound->loadSoundFile("coyote","client/sounds/coyote.ogg");
|
|
m_sound->loadSoundFile("crickets","client/sounds/crickets.ogg");
|
|
m_sound->loadSoundFile("crow","client/sounds/crow.ogg");
|
|
m_sound->loadSoundFile("desert","client/sounds/desert.ogg");
|
|
m_sound->loadSoundFile("drip_a","client/sounds/drippingwater_drip_a.ogg");
|
|
m_sound->loadSoundFile("drip_b","client/sounds/drippingwater_drip_b.ogg");
|
|
m_sound->loadSoundFile("drip_c","client/sounds/drippingwater_drip_c.ogg");
|
|
m_sound->loadSoundFile("drip_d","client/sounds/drippingwater_drip_d.ogg");
|
|
m_sound->loadSoundFile("drip_e","client/sounds/drippingwater_drip_e.ogg");
|
|
m_sound->loadSoundFile("drowning_gasp","client/sounds/drowning_gasp.ogg");
|
|
m_sound->loadSoundFile("lake_waves_calm","client/sounds/lake_waves_2_calm.ogg");
|
|
m_sound->loadSoundFile("lake_waves_variety","client/sounds/lake_waves_2_variety.ogg");
|
|
m_sound->loadSoundFile("owl","client/sounds/owl.ogg");
|
|
m_sound->loadSoundFile("rattlesnake","client/sounds/rattlesnake.ogg");
|
|
m_sound->loadSoundFile("rumble","client/sounds/rumble.ogg");
|
|
m_sound->loadSoundFile("scuba1","client/sounds/scuba1bubbles.ogg");
|
|
m_sound->loadSoundFile("scuba2","client/sounds/scuba1calm.ogg");
|
|
m_sound->loadSoundFile("scuba3","client/sounds/scuba1calm2.ogg");
|
|
m_sound->loadSoundFile("scuba4","client/sounds/scuba1interestingbubbles.ogg");
|
|
m_sound->loadSoundFile("scuba5","client/sounds/scuba1tubulentbubbles.ogg");
|
|
m_sound->loadSoundFile("splash","client/sounds/splash.ogg");
|
|
m_sound->loadSoundFile("swimming1","client/sounds/water_swimming_splashing.ogg");
|
|
m_sound->loadSoundFile("swimming2","client/sounds/water_swimming_splashing_breath.ogg");
|
|
m_sound->loadSoundFile("waves","client/sounds/waves.ogg");
|
|
m_sound->loadSoundFile("waves2","client/sounds/waves2.ogg");
|
|
m_sound->loadSoundFile("wolves","client/sounds/wolves.ogg");
|
|
|
|
verbosestream << "done" << std::endl;
|
|
|
|
verbosestream << "[AMBIANCE] Setting up environments...";
|
|
a_env[ENV_UNKNOWN] = ambiance_environment("Unknown", 0, 0, "", "", "", 0);
|
|
|
|
// setup the various environment's sounds and frequencies
|
|
a_env[ENV_CAVE] = ambiance_environment("Cave", 400, 6, "", "", "", 5.75);
|
|
a_env[ENV_CAVE].sounds[1] = env_sound("bats",.4);
|
|
a_env[ENV_CAVE].sounds[2] = env_sound("drip_a",.8);
|
|
a_env[ENV_CAVE].sounds[3] = env_sound("drip_b",.8);
|
|
a_env[ENV_CAVE].sounds[4] = env_sound("drip_c",.6);
|
|
a_env[ENV_CAVE].sounds[5] = env_sound("drip_d",.4);
|
|
a_env[ENV_CAVE].sounds[6] = env_sound("drip_e",.5);
|
|
|
|
a_env[ENV_UNDERWATER] = ambiance_environment("Underwater", 1001, 5, "splash", "drowning_gasp", "", 0);
|
|
a_env[ENV_UNDERWATER].sounds[1] = env_sound("scuba1",1);
|
|
a_env[ENV_UNDERWATER].sounds[2] = env_sound("scuba2",1);
|
|
a_env[ENV_UNDERWATER].sounds[3] = env_sound("scuba3",1);
|
|
a_env[ENV_UNDERWATER].sounds[4] = env_sound("scuba4",1);
|
|
a_env[ENV_UNDERWATER].sounds[5] = env_sound("scuba5",1);
|
|
|
|
a_env[ENV_INWATER] = ambiance_environment("Standing in Water", 1001, 2, "", "", "", 0);
|
|
a_env[ENV_INWATER].sounds[1] = env_sound("swimming1",.6);
|
|
a_env[ENV_INWATER].sounds[2] = env_sound("swimming2",.6);
|
|
|
|
a_env[ENV_PLAINS] = ambiance_environment("Plains", 300, 5, "", "", "", 4);
|
|
a_env[ENV_PLAINS].sounds[1] = env_sound("bird2",.2);
|
|
a_env[ENV_PLAINS].sounds[2] = env_sound("bird4",.2);
|
|
a_env[ENV_PLAINS].sounds[3] = env_sound("bird3",.2);
|
|
a_env[ENV_PLAINS].sounds[4] = env_sound("bird",.2);
|
|
a_env[ENV_PLAINS].sounds[5] = env_sound("birdsong",.2);
|
|
|
|
a_env[ENV_PLAINS_NIGHT] = ambiance_environment("Plains Night", 300, 0, "", "", "crickets", 6);
|
|
|
|
a_env[ENV_FOREST] = ambiance_environment("Forest", 700, 5, "", "", "", 3);
|
|
a_env[ENV_FOREST].sounds[1] = env_sound("bird2",.5);
|
|
a_env[ENV_FOREST].sounds[2] = env_sound("bird4",.5);
|
|
a_env[ENV_FOREST].sounds[3] = env_sound("bird3",.5);
|
|
a_env[ENV_FOREST].sounds[4] = env_sound("bird",.5);
|
|
a_env[ENV_FOREST].sounds[5] = env_sound("birdsong",.5);
|
|
|
|
a_env[ENV_FOREST_NIGHT] = ambiance_environment("Forest Night", 400, 3, "", "", "crickets", 4);
|
|
a_env[ENV_FOREST_NIGHT].sounds[1] = env_sound("owl",.8);
|
|
a_env[ENV_FOREST_NIGHT].sounds[2] = env_sound("coyote",.8);
|
|
a_env[ENV_FOREST_NIGHT].sounds[3] = env_sound("wolves",.9);
|
|
|
|
a_env[ENV_SNOW] = ambiance_environment("Snow", -1, 0, "", "", "", 0);
|
|
|
|
a_env[ENV_SNOW_NIGHT] = ambiance_environment("Snow Night", -1, 0, "", "", "", 0);
|
|
|
|
a_env[ENV_OCEAN] = ambiance_environment("Ocean", 800, 3, "", "", "", 1);
|
|
a_env[ENV_OCEAN].sounds[1] = env_sound("waves", .8);
|
|
a_env[ENV_OCEAN].sounds[2] = env_sound("waves2",.8);
|
|
a_env[ENV_OCEAN].sounds[3] = env_sound("seagull",.7);
|
|
|
|
a_env[ENV_DESERT] = ambiance_environment("Desert", 625, 1, "", "", "desert", 3);
|
|
a_env[ENV_DESERT].sounds[1] = env_sound("rattlesnake", .6 );
|
|
|
|
a_env[ENV_DESERT_NIGHT] = ambiance_environment("Desert Night", 400, 1, "", "", "", 3);
|
|
a_env[ENV_DESERT_NIGHT].sounds[1] = env_sound("desert", .8 );
|
|
|
|
a_env[ENV_JUNGLE] = ambiance_environment("Jungle", 725, 3, "", "", "", 2);
|
|
a_env[ENV_JUNGLE].sounds[1] = env_sound("bird4",.6);
|
|
a_env[ENV_JUNGLE].sounds[2] = env_sound("bird3",.6);
|
|
a_env[ENV_JUNGLE].sounds[3] = env_sound("bird",.5);
|
|
|
|
a_env[ENV_JUNGLE_NIGHT] = ambiance_environment("Jungle Night", 300, 3, "", "", "crickets", 3);
|
|
a_env[ENV_JUNGLE_NIGHT].sounds[1] = env_sound("owl",.7);
|
|
a_env[ENV_JUNGLE_NIGHT].sounds[2] = env_sound("coyote",.7);
|
|
a_env[ENV_JUNGLE_NIGHT].sounds[3] = env_sound("wolves",.8);
|
|
|
|
|
|
verbosestream << "done" << std::endl;
|
|
|
|
}
|
|
void Ambiance::doAmbiance(float dtime, u32 tod){
|
|
static bool newEnv = false;
|
|
m_timeOfDay = tod;
|
|
tickDelay += dtime;
|
|
doFades(dtime);
|
|
if ( startDelay > 3 && tickDelay > .1 ) { // delay ambiance 3 seconds from launch of game
|
|
lastPlay += dtime;
|
|
tickDelay = 0;
|
|
int env_result = readEnvironment();
|
|
if ( env_result != currentEnv ){
|
|
lastEnv = currentEnv;
|
|
currentEnv = env_result;
|
|
stopEnvironment(lastEnv); // change of enviroment stop all sounds that might be playing
|
|
if ( !a_env[currentEnv].on_start.empty() ){
|
|
playSound(a_env[currentEnv].on_start, 1);
|
|
}
|
|
newEnv = true;
|
|
actionstream << "[AMBIANCE] readEnvironment Results: " << a_env[currentEnv].name << std::endl;
|
|
if ( !a_env[currentEnv].background_sound.empty() ){
|
|
m_background_sound = m_sound->playSound(a_env[currentEnv].background_sound,true,0.0);
|
|
fadeSound(m_background_sound,1.25,0.6);
|
|
} else {
|
|
m_background_sound = 0;
|
|
}
|
|
} else {
|
|
newEnv = false;
|
|
}
|
|
|
|
if ( m_sounds_playing.rbegin() != m_sounds_playing.rend() ){
|
|
if ( m_sound->soundExists(m_sounds_playing.rbegin()->second) ){
|
|
return;
|
|
} else {
|
|
m_sounds_it it = m_sounds_playing.find(m_sounds_playing.rbegin()->first);
|
|
m_sounds_playing.erase(it);
|
|
}
|
|
}
|
|
|
|
if ( a_env[currentEnv].sound_count > 0 ){
|
|
if ( lastPlay >= a_env[currentEnv].next_sound_delay ){
|
|
srand (time(NULL));
|
|
int freq = rand() % 1000;
|
|
//verbosestream << "[AMBIANCE] Freq Random Number: " << to_string(freq) << " :: " << to_string(a_env[currentEnv].frequency) << std::endl;
|
|
if ( freq <= a_env[currentEnv].frequency ){
|
|
int s = ( rand() % a_env[currentEnv].sound_count ) + 1;
|
|
float v = ( rand() % 60 ); // add a little random variation to the sound volume
|
|
if ( v > 0 )
|
|
v = v / 100;
|
|
verbosestream << "[AMBIANCE] Sound selected: " << std::to_string(s) << " " << a_env[currentEnv].sounds[s].name << std::endl;
|
|
playSound(a_env[currentEnv].sounds[s].name, ( a_env[currentEnv].sounds[s].gain - v ));
|
|
}
|
|
} else {
|
|
//verbosestream << "[AMBIANCE] No Play" << to_string(lastPlay) <<std::endl;
|
|
}
|
|
}
|
|
} else {
|
|
startDelay += dtime;
|
|
}
|
|
}
|
|
|
|
// type is 0 - normal sound, 1 start sound, 2 stop sound
|
|
bool Ambiance::playSound(std::string name, float gain, bool fade){
|
|
float oGain = 0;
|
|
verbosestream << "[AMBIANCE] playSound(" << name << ")" << std::endl;
|
|
std::map<std::string, int>::iterator i = m_sounds_playing.find(name);
|
|
if ( i != m_sounds_playing.end() ){
|
|
// check the sound buffers to see if it's still playing
|
|
if ( m_sound->soundExists(i->second) ){
|
|
// get out of here so we don't play it again
|
|
verbosestream << "[AMBIANCE] " << name << " is already playing" << std::endl;
|
|
return false;
|
|
} else {
|
|
// remove it from our playing list
|
|
m_sounds_playing.erase(name);
|
|
}
|
|
}
|
|
|
|
if ( fade == true ){
|
|
oGain = gain;
|
|
gain = 0;
|
|
}
|
|
|
|
int id = m_sound->playSound(name, false, gain);
|
|
m_sounds_playing[name] = id;
|
|
|
|
if ( fade == true ){
|
|
fadeSound(id, 1.25, oGain);
|
|
}
|
|
|
|
lastPlay = 0;
|
|
return true;
|
|
}
|
|
|
|
void Ambiance::fadeSound(int soundid, float step, float gain){
|
|
float cGain = m_sound->getSoundGain(soundid);
|
|
fade_status f = fade_status(step,cGain,gain);
|
|
m_sounds_fading[soundid] = f;
|
|
}
|
|
|
|
void Ambiance::doFades(float dtime){
|
|
static float fadeDelay = 0;
|
|
fadeDelay += dtime;
|
|
if ( fadeDelay > 0.2 ){
|
|
float chkGain = 0;
|
|
for ( m_fading_it i = m_sounds_fading.begin(); i != m_sounds_fading.end(); i++ ){
|
|
if ( i->second.step < 0 )
|
|
chkGain = i->second.current_gain * -1;
|
|
else
|
|
chkGain = i->second.current_gain;
|
|
|
|
if ( chkGain < i->second.target_gain ){
|
|
i->second.current_gain += (i->second.step * fadeDelay);
|
|
if ( i->second.current_gain < 0 )
|
|
i->second.current_gain = 0;
|
|
|
|
if ( i->second.current_gain > 1 )
|
|
i->second.current_gain = 1;
|
|
|
|
|
|
m_sound->updateSoundGain(i->first,i->second.current_gain);
|
|
} else {
|
|
if ( i->second.target_gain <= 0 ){
|
|
m_sound->stopSound(i->first);
|
|
}
|
|
for ( m_sounds_it ii = m_sounds_playing.begin(); ii != m_sounds_playing.end(); ii++ ){
|
|
if ( ii->second == i->first )
|
|
m_sounds_playing.erase(ii->first);
|
|
}
|
|
m_sounds_fading.erase(i->first);
|
|
}
|
|
}
|
|
fadeDelay = 0;
|
|
}
|
|
}
|
|
|
|
int Ambiance::readEnvironment(){
|
|
//actionstream << "[AMBIANCE] readEnvironment() ";
|
|
ascending = false;
|
|
descending = false;
|
|
moving = false;
|
|
underwater = false;
|
|
|
|
LocalPlayer *p = m_env.getLocalPlayer();
|
|
v3f pos = p->getPosition();
|
|
v3s16 spos = p->getStandingNodePos();
|
|
|
|
// DAY AND NIGHT ARE KIND OF CATCH ALLS
|
|
// 19000 night starts
|
|
// 5000 morning starts
|
|
u32 t = m_timeOfDay;
|
|
|
|
if ( t > 5000 && t < 8000 )
|
|
TOD = MORNING;
|
|
|
|
if ( t > 8000 && t < 18500 )
|
|
TOD = DAY;
|
|
|
|
if ( t > 18500 && t < 19500 )
|
|
TOD = DUSK;
|
|
|
|
if ( t > 19500 || t < 5000 )
|
|
TOD = NIGHT;
|
|
|
|
if ( pos.Y > ( lastpos.Y + .5 ) )
|
|
ascending = true;
|
|
|
|
if ( pos.Y < ( lastpos.Y - .5 ) )
|
|
descending = true;
|
|
|
|
if ( pos.X != lastpos.X || pos.Z != lastpos.Z )
|
|
moving = true;
|
|
|
|
// if they aren't moving and the time of day hasn't changed don't recheck the environment
|
|
//if ( moving != true && TOD == lastTOD && currentEnv != ENV_INWATER )
|
|
// return currentEnv;
|
|
|
|
lastpos = pos;
|
|
lastTOD = TOD;
|
|
|
|
// find the nodes at their body positions
|
|
std::string lowerBodyNode = getNodeName(v3s16(spos.X, (spos.Y+1), spos.Z));
|
|
std::string upperBodyNode = getNodeName(v3s16(spos.X, (spos.Y+2), spos.Z));
|
|
std::string standingOnNode = getNodeName(v3s16(spos.X, spos.Y, spos.Z));
|
|
std::string aboveHeadNode = getNodeName(v3s16(spos.X, (spos.Y+3), spos.Z));
|
|
|
|
if ( ( upperBodyNode == WATER || upperBodyNode == MG_WATER || upperBodyNode == WATER_FLOWING || upperBodyNode == MG_WATER_FLOWING ) ){
|
|
underwater = true;
|
|
return ENV_UNDERWATER;
|
|
}
|
|
|
|
if ( moving == true && ( lowerBodyNode == WATER || lowerBodyNode == WATER_FLOWING || lowerBodyNode == MG_WATER || lowerBodyNode == MG_WATER_FLOWING || standingOnNode == WATER || standingOnNode == WATER_FLOWING || standingOnNode == MG_WATER || standingOnNode == MG_WATER_FLOWING ) ){
|
|
return ENV_INWATER;
|
|
}
|
|
|
|
|
|
// all of these happen above ground
|
|
if ( spos.Y > 0 ){
|
|
|
|
if ( nodesInRange(spos,10, 3, -1, JUNGLE_TREE,1,15) || nodesInRange(spos,10,2,-1,JUNGLE_GRASS,1,5) ){
|
|
if ( TOD == MORNING || TOD == DAY )
|
|
return ENV_JUNGLE;
|
|
else
|
|
return ENV_JUNGLE_NIGHT;
|
|
}
|
|
|
|
if ( nodesInRange(spos, 10, 4, -1, TREE,1,10) || nodesInRange(spos,10, 7, -1, LEAVES,1, 8 ) ){
|
|
if ( TOD == MORNING || TOD == DAY )
|
|
return ENV_FOREST;
|
|
else
|
|
return ENV_FOREST_NIGHT;
|
|
}
|
|
|
|
if ( nodesInRange(spos, 5, 1, 1, GRASS,1,8) ){
|
|
if ( TOD == MORNING || TOD == DAY )
|
|
return ENV_PLAINS;
|
|
else
|
|
return ENV_PLAINS_NIGHT;
|
|
}
|
|
|
|
if ( nodesInRange(spos, 5, 1, 2, SNOW, 1, 10) || nodesInRange(spos,5, 1, 2, DIRT_SNOW,1,10) ){
|
|
if ( TOD == MORNING || TOD == DAY )
|
|
return ENV_SNOW;
|
|
else
|
|
return ENV_SNOW_NIGHT;
|
|
}
|
|
|
|
if ( nodesInRange(spos, 10, 1, 2, DESERT_SAND, 1, 15) || nodesInRange(spos,10,1,2,DESERT_STONE,1,15) ){
|
|
if ( TOD == MORNING || TOD == DAY )
|
|
return ENV_DESERT;
|
|
else
|
|
return ENV_DESERT_NIGHT;
|
|
}
|
|
|
|
if ( spos.Y < 7 && spos.Y > -1 ){
|
|
if ( nodesInRange(spos,10,2,7,SAND, 1, 10) ){
|
|
if ( nodesInRange(spos, 20, 0, 7, WATER, 5, 8) || nodesInRange(spos, 20, 0, 7, MG_WATER, 5, 8) ){
|
|
return ENV_OCEAN;
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
if ( nodesInRange(spos, 3, 6, 0, STONE,1,25) ){
|
|
return ENV_CAVE;
|
|
}
|
|
|
|
return ENV_UNKNOWN;
|
|
}
|
|
|
|
bool Ambiance::nodesInRange(v3s16 pos, short searchRange, short searchAbove, short searchBelow, std::string nodeName, short accuracy, int count){
|
|
//verbosestream << "[AMBIANCE] nodesInRange(pos, " << to_string(searchRange) << ", " << nodeName << ")" << std::endl;
|
|
int nodeCount = 0;
|
|
std::string cNode;
|
|
// set positions for node checks
|
|
v3s16 p1 = v3s16((pos.X - searchRange), (pos.Y - searchBelow), (pos.Z - searchRange));
|
|
v3s16 p2 = v3s16((pos.X + searchRange), (pos.Y + searchAbove), (pos.Z + searchRange));
|
|
for ( int y = p1.Y; y < p2.Y; y+=accuracy ){
|
|
for ( int x = p1.X; x < p2.X; x+=accuracy ){
|
|
for ( int z = p1.Z; z < p2.Z; z+=accuracy ){
|
|
cNode = getNodeName(v3s16(x,y,z));
|
|
if ( cNode == nodeName )
|
|
nodeCount++;
|
|
}
|
|
if ( nodeCount > count )
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
std::string Ambiance::getNodeName(v3s16 pos){
|
|
MapNode n = m_env.getMap().getNodeNoEx(pos);
|
|
ContentFeatures f = m_env.getGameDef()->getNodeDefManager()->get(n);
|
|
return f.name;
|
|
}
|
|
|
|
int Ambiance::getNodeId(v3s16 pos){
|
|
MapNode n = m_env.getMap().getNodeNoEx(pos);
|
|
return n.getContent();
|
|
}
|
|
|
|
|
|
void Ambiance::stopEnvironment(int env){
|
|
// not going to bother seeing if the sounds playing are part of a certain environment just yet, just stop all sounds
|
|
for ( m_sounds_it i = m_sounds_playing.begin(); i != m_sounds_playing.end(); i++ ){
|
|
//m_sound->stopSound(i->second);
|
|
fadeSound(i->second,-1.25,0);
|
|
m_sounds_playing.erase(i->first); // go ahead and erase it here so we don't get double fade outs
|
|
}
|
|
|
|
if ( m_background_sound != 0 ){
|
|
fadeSound(m_background_sound,-0.5,0);
|
|
//m_sound->stopSound(m_background_sound);
|
|
m_background_sound = 0;
|
|
}
|
|
|
|
if ( !a_env[env].on_stop.empty() ){
|
|
playSound(a_env[env].on_stop,1);
|
|
}
|
|
|
|
lastPlay = 0;
|
|
}
|