public void PlaySound(SoundTypes type, AudioClip clip, bool loop = false, float pitch = 1f)
{
AudioSource src = new AudioSource();
switch (type)
{
case SoundTypes.Music:
src = Instantiate(srcBaseMusic, transform);
break;
case SoundTypes.SFX:
src = Instantiate(srcBaseSFX, transform);
break;
}
src.clip = clip;
src.loop = loop;
src.pitch = pitch;
src.Play();
if (!loop)
{
Destroy(src.gameObject, clip.length);
}
else
{
AudioSourceList.Add(src);
}
}
public Audio Load(AudioClip Clip, SoundTypes Type)
{
if (Clip == null)
{
return(null);
}
Audio instance = pool.GetFromPool();
instance.Source = instance.GetComponent <AudioSource>();
instance.Source.clip = Clip;
instance.Volume = GetVolume(Type);
instance.Mute = GetMute(Type);
instance.Loop = false;
switch (Type)
{
case SoundTypes.Music:
musicsList.Add(instance);
break;
case SoundTypes.Effect:
effectsList.Add(instance);
break;
}
return(instance);
}
public List <Interval> prepareIntervals(int numberOfIntervalsToCreate, List <Sound> sounds)
{
var intervals = new List <Interval>();
Random rnd = new Random();
int firstOctaveSymbol, secondOctaveSymbol, firstRandom, secondRandom, countOfSounds = sounds.Count;
string firstSoundName, secondSoundName;
int positionOfFirstSoundInArray, positionOfSecondSoundInArray, intervalDifference;
for (int i = 0; i < numberOfIntervalsToCreate; i++)
{
firstRandom = rnd.Next(0, countOfSounds);
secondRandom = rnd.Next(0, countOfSounds);
firstSoundName = sounds.ElementAt(firstRandom).Name;
secondSoundName = sounds.ElementAt(secondRandom).Name;
firstOctaveSymbol = Convert.ToInt32(sounds.ElementAt(firstRandom).GuitarString);
secondOctaveSymbol = Convert.ToInt32(sounds.ElementAt(secondRandom).GuitarString);
positionOfFirstSoundInArray = SoundTypes.SingleOrDefault(x => x.Key == firstSoundName).Value;
positionOfSecondSoundInArray = SoundTypes.SingleOrDefault(x => x.Key == secondSoundName).Value;
intervalDifference = positionOfFirstSoundInArray > positionOfSecondSoundInArray ?
(positionOfFirstSoundInArray - positionOfSecondSoundInArray) : (positionOfSecondSoundInArray - positionOfFirstSoundInArray);
var interval = calculateInterval(firstSoundName, secondSoundName, firstOctaveSymbol,
secondOctaveSymbol, intervalDifference, firstRandom, secondRandom, i);
intervals.Add(interval);
}
return(intervals);
}
public Sound(string name, SoundEffect effect, bool loop, float volFactor, SoundTypes type)
{
Name = name;
Instance = effect.CreateInstance();
Instance.IsLooped = loop;
VolumeFactor = volFactor;
this.type = type;
}
public Sound(string name, SoundEffect effect, bool loop, float volFactor, SoundTypes type)
{
Name = name;
Instance = effect.CreateInstance();
Instance.IsLooped = loop;
VolumeFactor = volFactor;
this.type = type;
}
public float GetVolume(SoundTypes Type)
{
if (specificVolumeState.ContainsKey(Type))
{
return(specificVolumeState[Type]);
}
return(0.0F);
}
public void AddSound(string name, SoundEffect effect, bool loop, float volFactor, SoundTypes type)
{
if (Sounds.ContainsKey(name))
return;
Sound s = new Sound(name, effect, loop, volFactor, type);
SetSoundFinalVolume(s);
Sounds.Add(name, s);
}
public bool GetMute(SoundTypes Type)
{
if (specificMuteState.ContainsKey(Type))
{
return(specificMuteState[Type]);
}
return(false);
}
public void PlayClip(SoundTypes key)
{
AudioClip clip;
if (sounds.TryGetValue(key, out clip))
{
audioSource.PlayOneShot(clip);
}
}
public void StopSound(SoundTypes type)
{
foreach (AudioSource audio in AudioSources)
{
if (audio.name.Equals(type.ToString()))
{
audio.Stop();
return;
}
}
}
public static void Play(SoundTypes sound)
{
switch (sound)
{
case SoundTypes.Start: {
player.SoundLocation = @"..\..\Sounds\def_star.wav";
player.Play();
break;
}
}
}
public void PlaySoundFile(SoundTypes fileName, string fileNumber)
{
try
{
var file = GetFileWithFileNumber(fileName, fileNumber);
SetFileToMediaElement(file);
}
catch (Exception ex)
{
_log.Info(ex.Message);
}
}
private string GetFileWithFileNumber(SoundTypes fileType, string fileNumber)
{
var fileName = GetFileName(fileType);
if (!string.IsNullOrEmpty(fileNumber))
{
var formatIndex = fileName.IndexOf('.');
fileName = fileName.Insert(formatIndex, fileNumber);
}
return(fileName);
}
public void PlaySound(SoundTypes a_type)
{
foreach (Sound sound in m_Sounds)
{
if (sound.Type == a_type)
{// Play the sounds
sound.Source.Play();
return;
}
}
Debug.Log("AudioManager: Sound Not found in list: " + a_type);
}
/// <summary>
/// Play a sound!
/// </summary>
public static void PlaySound(AudioClip audioClip, Vector3 position, SoundTypes soundType, bool loop = false, Transform parent = null)
{
GameObject gameObject = new GameObject();
gameObject.transform.position = position;
if (parent != null)
{
gameObject.transform.parent = parent;
}
NamedAudioSource namedAudioSource = gameObject.AddComponent <NamedAudioSource>();
namedAudioSource.PlaySound(audioClip, position, soundType, loop);
}
public AudioClip GetQuickSound(SoundTypes st)
{
if (quickSound == null)
{
quickSound = new Dictionary <SoundTypes, SoundData>();
foreach (SoundData sd in soundDatas)
{
quickSound.Add(sd.atype, sd);
}
}
return(quickSound[st].GetRandom());
}
public static void PlaySound(SoundTypes sound)
{
if (!sfx.ContainsKey(sound))
{
MyDebug.LogError($"Sound {sound} not found");
return;
}
if (!enabled)
{
return;
}
sfx[sound].Play();
}
public void PlaySound(SoundTypes _audioClip, float _volume = 1f) {
audioSource.volume = _volume;
switch (_audioClip) {
case SoundTypes.CLICK:
audioSource.clip = clickSound;
break;
case SoundTypes.HIGH_SCORE:
audioSource.clip = highScore;
break;
}
audioSource.Play ();
}
public void PlaySound(SoundTypes currentSound)
{
if (PlayerPrefs.GetInt("IsMuted") == 1)
{
return;
}
switch (currentSound)
{
case SoundTypes.Jump:
jumpSound.Play();
break;
case SoundTypes.Button:
buttonSound.Play();
break;
}
}
public Audio Register(AudioSource Source, SoundTypes Type)
{
Audio instance = gameObject.AddComponent <Audio>();
instance.Source = Source;
instance.Clip = Source.clip;
switch (Type)
{
case SoundTypes.Music:
musicsList.Add(instance);
break;
case SoundTypes.Effect:
effectsList.Add(instance);
break;
}
return(instance);
}
/// <summary>
/// Scales the volume of a sound by the Volume factor for its SoundType and the Master volumen Factor.
/// </summary>
/// <param name="soundVolFactor"></param>
/// <param name="type"></param>
/// <returns></returns>
private float GetFinalVolume(float soundVolFactor, SoundTypes type)
{
float final = 1.0f;
switch (type)
{
case SoundTypes.Effect:
final *= EffectVolumeFactor;
break;
case SoundTypes.Music:
final *= EffectVolumeFactor;
break;
default:
break;
}
final *= soundVolFactor * MasterVolumeFactor;
return(final);
}
public Audio Load(string Path, SoundTypes Type)
{
AudioClip clip = null;
if (audioClips.ContainsKey(Path))
{
clip = audioClips[Path];
}
else
{
clip = GameResourceManager.Instance.LoadAudioClip(Path);
if (clip != null)
{
audioClips.Add(Path, clip);
}
}
return(Load(clip, Type));
}
public void PlaySoundFile(SoundTypes fileName)
{
try
{
string file = fileName.Equals(SoundTypes.resume) ?
GetFileName(SoundTypes.stopped) : GetFileName(fileName);
if (fileName.Equals(SoundTypes.resume))
{
_mediaPlayer.Play();
}
else if (!fileName.Equals(SoundTypes.stopped))
{
SetFileToMediaElement(file);
}
}
catch (Exception ex)
{
_log.Info(ex.Message);
}
}
public void SetVolume(float Value, SoundTypes Type)
{
AudioPlayerList list = null;
switch (Type)
{
case SoundTypes.Music:
list = musicsList;
break;
case SoundTypes.Effect:
list = effectsList;
break;
}
specificVolumeState[Type] = Value;
for (int i = 0; i < list.Count; ++i)
{
list[i].Volume = Value;
}
}
public void playSounds(SoundTypes s)
{
Debug.Log(s);
switch (s)
{
case SoundTypes.Arrow:
a.PlayOneShot(list[0]);
break;
case SoundTypes.EnemyDead:
a.PlayOneShot(dyingSounds[Random.Range(0, dyingSounds.Length)]);
break;
case SoundTypes.PlayerDead:
a.PlayOneShot(list[2]);
break;
case SoundTypes.Attack:
a.PlayOneShot(list[3]);
break;
case SoundTypes.Explosion:
a.PlayOneShot(list[4]);
break;
case SoundTypes.PickupGold:
a.PlayOneShot(list[5]);
break;
case SoundTypes.PickupHealth:
a.PlayOneShot(list[6]);
break;
case SoundTypes.ShopMenu:
a.PlayOneShot(list[7]);
break;
}
}
public SoundEntriesEntry(int soundId, SoundTypes soundType, [NotNull] TStringType name, [NotNull] GenericStaticallySizedArrayChunkTen <TStringType> file, [NotNull] GenericStaticallySizedArrayChunkTen <int> frequency, [NotNull] TStringType baseDirectory, float volume, SoundInterfaceFlags flags, float minimumDistance, float distanceCutoff, int eaxDefinition, int soundEntriesAdvancedId)
{
if (!Enum.IsDefined(typeof(SoundTypes), soundType))
{
throw new InvalidEnumArgumentException(nameof(soundType), (int)soundType, typeof(SoundTypes));
}
if (soundId <= 0)
{
throw new ArgumentOutOfRangeException(nameof(soundId));
}
SoundId = soundId;
SoundType = soundType;
Name = name ?? throw new ArgumentNullException(nameof(name));
File = file ?? throw new ArgumentNullException(nameof(file));
Frequency = frequency ?? throw new ArgumentNullException(nameof(frequency));
BaseDirectory = baseDirectory ?? throw new ArgumentNullException(nameof(baseDirectory));
Volume = volume;
Flags = flags;
MinimumDistance = minimumDistance;
DistanceCutoff = distanceCutoff;
EAXDefinition = eaxDefinition;
SoundEntriesAdvancedId = soundEntriesAdvancedId;
}
public int PlaySound(SoundTypes st, Vector2?pos = null, bool muteMusic = false, float playDelay = -1f, float endDelay = -1f)
{
AudioClip clip = GetQuickSound(st);
if (clip == null)
{
return(-1);
}
GameObject prefab = new GameObject();
prefab.name = "Sound-" + st;
AudioSource ass = prefab.AddComponent <AudioSource>();
ass.loop = false;
ass.volume = soundVolume;
ass.clip = clip;
ass.mute = MuteAllSound;
prefab.transform.SetParent(soundContainer);
if (pos.HasValue)
{
prefab.transform.position = pos.Value;
}
else
{
prefab.transform.position = Vector2.zero;
}
SoundStopper ss = prefab.AddComponent <SoundStopper>();
ss.MuteMusic = muteMusic;
ss.SoundEndDuration = endDelay;
ss.SoundStartDelay = playDelay;
Sounds.Add(ass.GetInstanceID(), ass);
return(ass.GetInstanceID());
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// * New Method: Revert Sound Object
//----------------------------------------------------
// Called after a sound in the playlist has been played.
// Makes the other sounds stop showing visual cues
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
public void RevertSoundObject(SoundTypes eSound)
{
switch (eSound)
{
case SoundTypes.CENTER_TAMBOURINE_AREA:
m_rInstrumentManager.InstrumentColoursManager.HideCenterTambourineTarget();
break;
case SoundTypes.MIDDLE_TAMBOURINE_AREA:
m_rInstrumentManager.InstrumentColoursManager.HideMiddleTambourineTarget();
break;
case SoundTypes.OUTER_TAMBOURINE_AREA:
m_rInstrumentManager.InstrumentColoursManager.HideOuterTambourineTarget();
break;
case SoundTypes.CYMBAL_SHAKER_SOUND_1:
case SoundTypes.CYMBAL_SHAKER_SOUND_2:
case SoundTypes.CYMBAL_SHAKER_SOUND_3:
case SoundTypes.CYMBAL_SHAKER_SOUND_4:
case SoundTypes.CYMBAL_SHAKER_SOUND_5:
case SoundTypes.CYMBAL_SHAKER_SOUND_6:
m_rInstrumentManager.CurrentAutoPlayCymbal.StopCymbalShake();
break;
case SoundTypes.MOVE_TAMBOURINE_SOUND:
case SoundTypes.RATTLE_TAMBOURINE_SHAKE:
case SoundTypes.SOFT_TAMBOURINE_SHAKE:
case SoundTypes.HARD_TAMBOURINE_SHAKE:
m_rInstrumentManager.ShowNormalInstrumentState();
break;
default:
break;
}
}
/// <summary>
/// Funkcja zwracajaca pelna sciezke do pliku dzwiekowego (mp3) po zadanym
/// typie dzwieku do zagrania
/// </summary>
/// <param name="sound">Typ dzwieku</param>
/// <returns>Pelna sciezka do pliku wav z dzwiekiem</returns>
public String FindSound(SoundTypes sound)
{
return soundDirectoryPath
+ (String)resourcesManager.GetObject(sound.ToString());
}
public Sound(string name, string filename, SoundTypes soundType)
{
Name = name;
Filename = filename;
SoundType = soundType;
}
/// <summary>
/// Adds an effect (no looping)
/// </summary>
/// <param name="name"></param>
/// <param name="effect"></param>
public void AddSound(string name, SoundEffect effect, SoundTypes type)
{
AddSound(name, effect, false, 1.0f, type);
}
public void AddSound(string name, SoundEffect effect, bool loop, float volFactor, SoundTypes type)
{
if (Sounds.ContainsKey(name))
{
return;
}
Sound s = new Sound(name, effect, loop, volFactor, type);
SetSoundFinalVolume(s);
Sounds.Add(name, s);
}
/// <summary>
/// Scales the volume of a sound by the Volume factor for its SoundType and the Master volumen Factor.
/// </summary>
/// <param name="soundVolFactor"></param>
/// <param name="type"></param>
/// <returns></returns>
private float GetFinalVolume(float soundVolFactor, SoundTypes type)
{
float final=1.0f;
switch (type)
{
case SoundTypes.Effect:
final *= EffectVolumeFactor;
break;
case SoundTypes.Music:
final *= EffectVolumeFactor;
break;
default:
break;
}
final *= soundVolFactor * MasterVolumeFactor;
return final;
}
public int PlayTambourineSound(InstrumentManager.InstrumentMode eTambourineType, SoundTypes eSoundType)
{
return(AudioSourceManager.PlayAudioClip(GetTambourineSound(eTambourineType, eSoundType)));
}
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// * New Methods: Play Tambourine Sound
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
public int PlayTambourineSound(SoundTypes eSoundType)
{
return(PlayTambourineSound(m_rInstrumentManager.CurrentInstrumentMode, eSoundType));
}
/// <summary>
/// Funkcja grajaca dzwiek krokow i zwracajaca obiekt z dzwiekiem
/// do manualnej modyfikacji przez klienta
/// </summary>
/// <returns>Obiekt z dzwiekiem krokow</returns>
public static SoundDescriptor StartSteps(SoundTypes sound, Vector3 position)
{
String soundName = nameFinder.FindSound(sound); //znalezienie sciezki
SoundDescriptor soundDesc =
new SoundDescriptor(soundCard, soundName, position, true);
soundDesc.Play();
soundList.Add(soundDesc);
return soundDesc;
}
/// <summary>
/// Funkcja grajaca zadany dzwiek w przestrzeni 3D
/// </summary>
/// <param name="sound">Typ wyliczeniowy z typem dzwieko</param>
/// <param name="position">Wektor z pozycja w przestrzeni 3D</param>
public static void PlaySound(SoundTypes sound, Vector3 position)
{
String soundName = nameFinder.FindSound(sound); //znalezienie sciezki
SoundDescriptor soundDesc =
new SoundDescriptor(soundCard, soundName, position, false);
soundDesc.Play();
soundList.Add(soundDesc);
}
/// <summary>
/// Adds an effect (no looping)
/// </summary>
/// <param name="name"></param>
/// <param name="effect"></param>
public void AddSound(string name, SoundEffect effect, SoundTypes type)
{
AddSound(name, effect, false, 1.0f, type);
}
