public static void PlayOneShot(AudioClips e_Clips)
{
switch (e_Clips)
{
case AudioClips.DRIFT:
I.audioSorce.PlayOneShot(I.Drift);
break;
case AudioClips.HIT:
I.audioSorce.PlayOneShot(I.Hit[Random.Range(0, 3)]);
break;
case AudioClips.DEATH:
I.audioSorce.PlayOneShot(I.Death);
break;
case AudioClips.CLEAR:
I.audioSorce.PlayOneShot(I.Clear);
break;
case AudioClips.GET:
I.audioSorce.PlayOneShot(I.Get);
break;
}
}
public void Play(AudioClips audioClip)
{
switch (audioClip)
{
case AudioClips.ArrowNock:
_audioSource.PlayOneShot(ArrowNock);
break;
case AudioClips.StringPull:
_audioSource.PlayOneShot(StringPull);
break;
case AudioClips.StringRelease:
_audioSource.PlayOneShot(StringRelease);
break;
case AudioClips.ArrowSwoosh:
_audioSource.PlayOneShot(ArrowSwoosh);
break;
case AudioClips.ArrowImpact:
_audioSource.PlayOneShot(ArrowImpact);
break;
default:
throw new ArgumentOutOfRangeException("audioClip", audioClip, null);
}
}
private void Awake()
{
this.gameObject.AddComponent <AudioListener>();
bgmSource = this.gameObject.AddComponent <AudioSource>();
clips = ScriptableObjectUtil.GetScriptableObject <AudioClips>();
}
public void UpdateStateSelectedRuleAudioClip(int selectedRule)
{
var audioClip = AudioClips.Where((x) => x.Label.Equals("State selected rule")).FirstOrDefault();
string audioDirectory = Path.Combine(DirectoryMgr.AudioClipsDirectory, "Ruleset");
if (audioClip == null)
{
audioClip = new AudioClip()
{
Category = "Ruleset",
Label = "State selected rule",
Tooltip = "State selected rule",
ButtonColour = ColourHelper.StatementColour
};
AudioClips.Add(audioClip);
}
List <string> clips = new List <string>();
StringBuilder sb = new StringBuilder();
string ruleText = TextHelper.GetRuleNumberText(selectedRule - 1);
sb.Append(ruleText + ": ");
clips.Add(Path.Combine(audioDirectory, ruleText));
sb.Append(Rules[selectedRule - 1].StateText);
clips.Add(Rules[selectedRule - 1].TriggerClip.StateAudioFile);
clips.Add(Rules[selectedRule - 1].ActionClip.StateAudioFile);
audioClip.StateText = sb.ToString();
audioClip.StateAudioFile = AudioMgr.CombineAudioClips(clips);
}
public static void PlaySound(this MonoBehaviour sfxSource, AudioClips clip,
SoundType type = SoundType.Default, Vector3?location = null)
{
AudioClipData cd = AudioDatabase[clip];
PlaySound(sfxSource, cd?.Clip, type == SoundType.Default?cd?.SoundType ?? type:type, location);
}
/// <summary> Plays the specified audio </summary>
/// <param name="_clipName"> Audio to play </param>
public void PlayAudio(AudioClips _clipName)
{
if (!Environment.instance.musicController.SfxEnabled)
{
return;
}
if (_clipName == AudioClips.None)
{
return;
}
AudioClip clip;
switch (_clipName)
{
case AudioClips.Select: clip = audioClipsSelect[Random.Range(0, audioClipsSelect.Length)]; break;
case AudioClips.Switch: clip = audioClipsSwitch[Random.Range(0, audioClipsSwitch.Length)]; break;
case AudioClips.Start: clip = audioClipStart; break;
case AudioClips.Swoosh: clip = audioClipSwoosh; break;
case AudioClips.LevelUp: clip = audioClipLevelUp; break;
default: throw new UnityException("Unhandled Audio Clip " + _clipName);
}
audioSource.PlayOneShot(clip);
}
//
public void PlayClip(AudioClips id, float volume = 1f)
{
// Audio Clip
AudioClip audioClip = null;
switch (id)
{
case AudioClips.AttackGrunt:
audioClip = audioAttackGrunt;
break;
case AudioClips.AttackHit:
audioClip = audioAttackHit;
break;
case AudioClips.AttackBlocked:
audioClip = audioAttackBlock;
break;
case AudioClips.Damaged:
audioClip = audioDamaged;
break;
case AudioClips.Death:
audioClip = audioDeath;
break;
}
// Play Audio at Listener Location
if (audioClip)
{
AudioSource.PlayClipAtPoint(audioClip, audioListener.transform.position, volume);
}
}
public AudioClipData this[AudioClips index]
{
get
{
AudioClips.TryGetValue((ulong)index, out AudioClipData data);
return(data);
}
}
/// <summary>
/// Gets a preloaded <see cref="AudioInfo"/>
/// </summary>
/// <returns>
/// A prepared <see cref="AudioInfo"/> ready to be used by a <see cref="IAudioPlayer"/>
/// </returns>
/// <param name='audio'>
/// <see cref="AudioInfo"/> enum
/// </param>
public static AudioInfo GetAudio(AudioClips audio)
{
AudioInfo audioInfo;
if (!_audioCache.TryGetValue(audio, out audioInfo)) {
Logger.Error(TAG, String.Format("Unable to fetch audio clip \"{0}\"", audio));
}
return audioInfo;
}
public void PlaySound(AudioClips clip)
{
AudioClip audioClip = ResourceLoader.GetAudioClipByName(clip.ToString());
if (audioClip != null)
{
audioSource?.PlayOneShot(audioClip);
}
}
private void Awake()
{
if (!GetComponent <AudioSource>())
{
_audio = gameObject.AddComponent <AudioSource>();
}
clips = ScriptableObjectUtil.GetScriptableObject <AudioClips>();
}
public void UpdateRuleDeletedAudioClip(int ruleNumber)
{
var audioClip = AudioClips.Where((x) => x.Label.Equals("OK, rule deleted")).FirstOrDefault();
if (audioClip != null)
{
RuleClipGenerator.UpdateRuleDeletedAudioClip(audioClip, ruleNumber);
}
}
internal void SetupComponents()
{
anim = gameObject.GetComponent <Animator>();
anim.SetFloat("Speed", 1f);
rb2d = gameObject.GetComponent <Rigidbody2D>();
Clips = ClipsCarrier.GetComponent <AudioClips>();
}
// Schedule the passed clip to be played next
public void Enqueue(AudioClip audioClip)
{
AudioClips.Enqueue(audioClip);
if (AudioState == AudioState.NoClip)
{
AudioState = AudioState.Playing;
AudioSource.clip = AudioClips.Dequeue();
AudioSource.Play();
}
}
public void Clear()
{
Debug.LogWarning("Clearing audio database");
AudioClips.Clear();
ClipTypes.Clear();
_audioClips = null;
_clipIds = null;
_clipTypes = null;
}
public void PlayTakenDamageNotification()
{
// @NOTE(sdsmith): There is a potential case where this function could
// be called after the player dies. Must check to avoid nullptr.
if (audioSource)
{
AudioClip clip = AudioClips.GetRand(AudioClips.maleGrunts);
audioSource.PlayOneShot(clip);
}
}
public void OnAfterDeserialize()
{
AudioClips.Clear();
ClipTypes.Clear();
for (int i = 0; i < _audioClips.Length; i++)
{
AudioClips.Add(_clipIds[i], new AudioClipData(_audioClips[i], _clipTypes[i]));
ClipTypes.Add(_audioClips[i], _clipTypes[i]);
}
}
/// <summary>
/// Gets a preloaded <see cref="AudioInfo"/>
/// </summary>
/// <returns>
/// A prepared <see cref="AudioInfo"/> ready to be used by a <see cref="IAudioPlayer"/>
/// </returns>
/// <param name='audio'>
/// <see cref="AudioInfo"/> enum
/// </param>
public static AudioInfo GetAudio(AudioClips audio)
{
AudioInfo audioInfo;
if (!_audioCache.TryGetValue(audio, out audioInfo))
{
Logger.Error(TAG, String.Format("Unable to fetch audio clip \"{0}\"", audio));
}
return(audioInfo);
}
public void UpdateListRulesAudioClip()
{
var audioClip = AudioClips.Where((x) => x.Label.Equals("List rules")).FirstOrDefault();
string audioDirectory = Path.Combine(DirectoryMgr.AudioClipsDirectory, "Ruleset");
string deviceDirectory = Path.Combine(DirectoryMgr.AudioClipsDirectory, DeviceName);
if (audioClip == null)
{
audioClip = new AudioClip()
{
Category = "Ruleset",
Label = "List rules",
Tooltip = "List rules",
ButtonColour = ColourHelper.StatementColour
};
AudioClips.Add(audioClip);
}
List <string> clips = new List <string>();
StringBuilder sb = new StringBuilder();
switch (Rules.Count)
{
case 0:
sb.Append("Currently I have no rules for the " + DeviceName);
clips.Add(Path.Combine(deviceDirectory, String.Format("Currently I have no rules for the {0}", DeviceName)));
break;
case 1:
sb.Append("I have one rule for the " + DeviceName + ".\n");
sb.Append(Rules[0].StateText);
clips.Add(Path.Combine(deviceDirectory, String.Format("I have one rule for the {0}", DeviceName)));
clips.Add(Rules[0].TriggerClip.StateAudioFile);
clips.Add(Rules[0].ActionClip.StateAudioFile);
break;
default:
string numberTxt = TextHelper.GetNumberText(Rules.Count);
sb.Append("I have " + numberTxt + " rules for the " + DeviceName + ".\n");
for (int i = 0; i < Rules.Count; i++)
{
sb.Append(TextHelper.GetRuleNumberText(i) + ": ");
sb.Append(Rules[i].StateText + "\n");
}
clips.Add(Path.Combine(deviceDirectory, String.Format("I have " + numberTxt + " rules for the {0}", DeviceName)));
for (int i = 0; i < Rules.Count; i++)
{
clips.Add(Path.Combine(audioDirectory, TextHelper.GetRuleNumberText(i)));
clips.Add(Rules[i].TriggerClip.StateAudioFile);
clips.Add(Rules[i].ActionClip.StateAudioFile);
}
break;
}
audioClip.StateText = sb.ToString();
audioClip.StateAudioFile = AudioMgr.CombineAudioClips(clips);
}
private void Start()
{
//initialze variables
playerRb = GetComponent <Rigidbody>();
bs = GameObject.Find("Floor").GetComponent <BallSpawner>();
ballCollection = GetComponent <BallCollection>();
audioClips = GetComponent <AudioClips>();
audioSource = GetComponent <AudioSource>();
scene = SceneManager.GetActiveScene();
jumpForce = 10;
}
void Start()
{
LaserShot = laserShot;
Collision = collision;
Accelerate = accelerate;
Death = death;
instance = this;
}
// Fades out the current clip, if any, and clears the queue
public void FadeoutInterrupt()
{
AudioClips.Clear();
if (AudioState == AudioState.Playing)
{
AudioState = AudioState.FadingOut;
}
else if (AudioState == AudioState.Paused || AudioState == AudioState.NoClip)
{
AudioState = AudioState.NoClip;
AudioSource.clip = null;
}
}
public void PlaySoundOneShot(AudioClips aAudioClip, Soundtypes aSoundType)
{
AudioSource TempAudioSource = m_AudioSources[(int)aSoundType];
if (TempAudioSource == null)
{
Debug.Log("Audio source: " + aSoundType + " is Null");
return;
}
TempAudioSource.loop = false;
TempAudioSource.PlayOneShot(GetAudioClip(aAudioClip));
}
private void Awake()
{
if (main == null)
{
main = this;
}
else if (main != this)
{
Destroy(gameObject);
}
ass = GetComponent <AudioSource>();
}
public void PlaySoundScheduled(AudioClips aAudioClip, double time, Soundtypes aSoundType)
{
AudioSource TempAudioSource = m_AudioSources[(int)aSoundType];
if (TempAudioSource == null)
{
Debug.Log("Audio source: " + aSoundType + " is Null");
return;
}
TempAudioSource.loop = false;
TempAudioSource.clip = GetAudioClip(aAudioClip);
TempAudioSource.PlayScheduled(time);
}
public void PlaySoundDelayed(AudioClips aAudioClip, float delay, Soundtypes aSoundType)
{
AudioSource TempAudioSource = m_AudioSources[(int)aSoundType];
if (TempAudioSource == null)
{
Debug.Log("Audio source: " + aSoundType + " is Null");
return;
}
TempAudioSource.loop = false;
TempAudioSource.clip = GetAudioClip(aAudioClip);
TempAudioSource.PlayDelayed(delay);
}
public void PlaySoundRepeating(AudioClips aAudioClip, Soundtypes aSoundType)
{
AudioSource TempAudioSource = m_AudioSources[(int)aSoundType];
if (TempAudioSource == null)
{
Debug.Log("Audio source: " + aSoundType + " is Null");
return;
}
TempAudioSource.loop = true;
TempAudioSource.clip = GetAudioClip(aAudioClip);
TempAudioSource.Play();
}
public AudioClip GetAudioClip(AudioClips aAudioClips)
{
string audioClipPath = "";
if (aAudioClips == AudioClips.Exploration)
{
audioClipPath = "Audio/Music/Overworld";
}
if (aAudioClips == AudioClips.Combat)
{
audioClipPath = "Audio/Music/Encounter";
}
if (aAudioClips == AudioClips.Selection)
{
audioClipPath = "Audio/SoundEffect/Selection";
}
if (aAudioClips == AudioClips.FireBall)
{
audioClipPath = "Audio/SoundEffect/Fireball";
}
if (aAudioClips == AudioClips.Encounter)
{
audioClipPath = "Audio/SoundEffect/EnemyEncounter2";
}
if (aAudioClips == AudioClips.Accept)
{
audioClipPath = "Audio/SoundEffect/Accept";
}
if (aAudioClips == AudioClips.FootStep)
{
audioClipPath = "Audio/SoundEffect/FootSteps";
}
if (aAudioClips == AudioClips.WallBounce)
{
audioClipPath = "Audio/SoundEffect/WallBounce";
}
return(Resources.Load <AudioClip>(audioClipPath));;
}
public bool IsPlaying(AudioClips audioId)
{
AudioSource source;
if (_gameAudioDictionary.TryGetValue(audioId, out source))
{
return(source.isPlaying);
}
else
{
Debug.LogWarning("Tried to stop audio with an id that does not exist in the current audio controller dictionary. Did you forget to add it?");
return(false);
}
}
public void Play(AudioClips clip)
{
switch (clip)
{
case (AudioClips.Click): source.PlayOneShot(OnClick); break;
case (AudioClips.BackClick): source.PlayOneShot(OnBackClick); break;
case (AudioClips.OnComplite): source.PlayOneShot(OnComplite); break;
case (AudioClips.OnFail): source.PlayOneShot(OnFail); break;
case (AudioClips.OnEnter): source.PlayOneShot(OnEnter); break;
}
}
// Fades out the current clip, if any, clears the queue and play the passed clip next
public void PlayFadeoutInterrupt(AudioClip audioClip)
{
AudioClips.Clear();
AudioClips.Enqueue(audioClip);
if (AudioState == AudioState.Playing)
{
AudioState = AudioState.FadingOut;
}
else if (AudioState == AudioState.Paused || AudioState == AudioState.NoClip)
{
AudioState = AudioState.Playing;
AudioSource.clip = AudioClips.Dequeue();
AudioSource.Play();
}
}
// Update is called once per frame
void FixedUpdate()
{
if (!isLocalPlayer)
return;
/*
--------------------------
| Deplacement de la camera |
--------------------------
*/
// Get new distance
if (!this.pause)
if (Input.GetKey("left ctrl"))
this.distance -= Input.mouseScrollDelta.y * this.sensitivityScroll;
this.distance = Mathf.Clamp(this.distance, this.distanceMin, this.distanceMax);
// TPS
if (this.distance > this.distanceMin)
{
// Set value
Vector3 posPersonnage = this.character.transform.position;
Vector3 posCamera = this.cam.transform.position;
// Get the drag
Vector2 deltaMouse = Vector2.zero;
if (!this.pause)
deltaMouse = new Vector2(-Input.GetAxis("Mouse X"), -Input.GetAxis("Mouse Y"));
deltaMouse *= this.sensitivity * this.distance * Time.deltaTime;
// Moove the camera
this.cam.transform.Translate(deltaMouse.x, Mathf.Clamp(deltaMouse.y, this.yMin * this.distance + posPersonnage.y - posCamera.y, this.yMax * this.distance + posPersonnage.y - posCamera.y), 0);
this.cam.transform.LookAt(this.character.transform.position + this.translateReferentiel);
// Adjust the distance
float distance = (float)Mathf.Sqrt(Mathf.Pow(posPersonnage.x - posCamera.x, 2) + Mathf.Pow(posPersonnage.y - posCamera.y, 2) + Mathf.Pow(posPersonnage.z - posCamera.z, 2));
this.cam.transform.Translate(0, 0, distance - this.distance);
}
// FPS
else
{
this.cam.transform.position = this.character.transform.position + this.translateReferentiel;
if (!this.pause)
{
this.rotationX += Input.GetAxis("Mouse X") * this.sensitivity * 100 * Time.deltaTime;
this.rotationY += Input.GetAxis("Mouse Y") * this.sensitivity * 100 * Time.deltaTime;
}
this.rotationY = Mathf.Clamp(this.rotationY, this.yMinFPS, this.yMaxFPS);
this.cam.transform.localEulerAngles = new Vector3(-this.rotationY, this.rotationX, 0);
this.character.transform.eulerAngles = new Vector3(0, this.rotationX + 180, 0);
}
/*
---------------------------
| Deplacement du personnage |
---------------------------
*/
// Recupere les inputs
bool forward = !this.pause && Input.GetButton("Forward");
bool back = !this.pause && Input.GetButton("Back");
bool right = !this.pause && Input.GetButton("Right");
bool left = !this.pause && Input.GetButton("Left");
bool jump = !this.pause && Input.GetButton("Jump");
isSprinting = !this.pause && Input.GetButton("Sprint");
ismoving = forward || back || right || left || jump;
Vector3 move = new Vector3(0, 0, 0);
// Jump
if (jump && !this.isJumping && this.coolDownJump <= 0 && ! this.specm.isSpec)
{
this.isJumping = true;
this.character.GetComponent<Rigidbody>().AddForce(0, jumpForce + this.syncChar.Jump, 0);
this.coolDownJump = 0.2f;
}
else if (!this.isJumping && this.coolDownJump > 0)
{
this.coolDownJump -= Time.deltaTime;
}
// Moves
float angle = Mathf.Deg2Rad * (360 - this.cam.transform.rotation.eulerAngles.y);
int rotation = 0;
if ((right == left))
{
if (forward && !back)
{
move.Set(-Mathf.Sin(angle), 0, Mathf.Cos(angle));
rotation = 180;
}
else if (back && !forward)
{
move.Set(Mathf.Sin(angle), 0, -Mathf.Cos(angle));
rotation = 0;
}
}
else if ((forward == back))
{
angle += Mathf.PI / 2;
if (right && !left)
{
move.Set(Mathf.Sin(angle), 0, -Mathf.Cos(angle));
rotation = -90;
}
else if (!right && left)
{
move.Set(-Mathf.Sin(angle), 0, Mathf.Cos(angle));
rotation = 90;
}
}
else if (forward)
{
if (right)
{
angle -= Mathf.PI / 4;
move.Set(-Mathf.Sin(angle), 0, Mathf.Cos(angle));
rotation = -135;
}
else
{
angle += Mathf.PI / 4;
move.Set(-Mathf.Sin(angle), 0, Mathf.Cos(angle));
rotation = 135;
}
}
else
{
if (right)
{
angle += Mathf.PI / 4;
move.Set(Mathf.Sin(angle), 0, -Mathf.Cos(angle));
rotation = -45;
}
else
{
angle -= Mathf.PI / 4;
move.Set(Mathf.Sin(angle), 0, -Mathf.Cos(angle));
rotation = 45;
}
}
bool isMoving = move.x != 0 || move.z != 0;
// jump while in spec mode
if (this.specm.isSpec && jump)
{
this.isJumping = true;
move += Vector3.up * ((isSprinting) ? -1f : 1f);
}
if (this.ismoving)
{
this.objectiv = null;
this.orbiting = false;
this.orbsense = true;
}
// Apply the moves with the animation
if (this.isJumping)
{
this.interactDistance = float.PositiveInfinity;
anim.SetInteger("Action", 3);
if (isSprinting)
move *= this.sprintSpeed + this.jumpingBoost + this.syncChar.Speed;
else
move *= this.walkSpeed + this.jumpingBoost + this.syncChar.Speed;
}
else
{
if (isMoving)
{
this.interactDistance = float.PositiveInfinity;
if (isSprinting)
{
move *= this.sprintSpeed + this.syncChar.Speed;
this.anim.SetInteger("Action", 2);
if (this.soundAudio.IsReady(2))
{
AudioClips[] runs = new AudioClips[] { AudioClips.Run1, AudioClips.Run2, AudioClips.Run3 };
AudioClips runRand = runs[Random.Range(0, runs.Length)];
this.soundAudio.PlaySound(runRand, 1f, .2f, 2);
this.soundAudio.CmdPlaySound(runRand, 1f);
}
}
else
{
move *= this.walkSpeed + this.syncChar.Speed;
this.anim.SetInteger("Action", 1);
if (this.soundAudio.IsReady(1))
{
AudioClips[] walks = new AudioClips[] { AudioClips.Walk1, AudioClips.Walk2, AudioClips.Walk3 };
AudioClips walkRand = walks[Random.Range(0, walks.Length)];
this.soundAudio.PlaySound(walkRand, 1f, .325f, 1);
this.soundAudio.CmdPlaySound(walkRand, 1f);
}
}
}
else if (this.objectiv != null)
{
Vector3 pos = this.objectiv.transform.position;
this.anim.SetInteger("Action", 1);
Vector3 viewRot = new Vector3(-pos.x, this.character.transform.position.y, -pos.z) - new Vector3(-this.character.transform.position.x, this.character.transform.position.y, -this.character.transform.position.z);
if (viewRot != Vector3.zero)
{
Quaternion targetRotation = Quaternion.LookRotation(viewRot);
this.character.transform.rotation = Quaternion.Lerp(this.character.transform.rotation, targetRotation, Time.deltaTime * 5);
}
move = -this.character.transform.forward;
move *= this.walkSpeed + this.syncChar.Speed;
if (Vector3.Distance(this.character.transform.position, pos) < this.interactDistance)
{
this.objectiv = null;
this.interactDistance = float.PositiveInfinity;
}
}
else if (this.anim.GetInteger("Action") <= 3 || !Input.GetButton("Fire2") || this.im.NearElement == null)
this.anim.SetInteger("Action", 0);
}
if (this.cdDisable > 0)
this.cdDisable -= Time.deltaTime;
else
{
this.character.GetComponent<Rigidbody>().velocity = new Vector3(0, (this.specm.isSpec)? 0 : this.character.GetComponent<Rigidbody>().velocity.y, 0);
this.character.GetComponent<Rigidbody>().AddForce(move);
this.cam.GetComponent<Rigidbody>().velocity = Vector3.zero;
this.cam.GetComponent<Rigidbody>().AddForce(move);
if (isMoving)
{
Vector3 rotCam = new Vector3(this.character.transform.eulerAngles.x, this.cam.transform.eulerAngles.y + rotation, this.character.transform.eulerAngles.z);
this.character.transform.rotation = Quaternion.Lerp(this.character.transform.rotation, Quaternion.Euler(rotCam), Time.deltaTime * 5);
}
}
if (orbiting)
{
this.character.GetComponent<Rigidbody>().velocity = Vector3.zero;
this.cam.GetComponent<Rigidbody>().velocity = Vector3.zero;
this.character.transform.LookAt (this.specm.Orbite.Center.transform);
this.cam.transform.LookAt (this.specm.Orbite.Center.transform);
Vector3 force = Vector3.Normalize(Vector3.Cross (this.specm.Orbite.RotAxis, this.character.transform.forward)) * ((this.orbsense)? 1 : -1) * this.walkSpeed;
this.character.GetComponent<Rigidbody>().AddForce(force);
this.cam.GetComponent<Rigidbody>().AddForce(force);
}
}
public void Set(AudioClips audio)
{
_audioSrc.clip = AudioLoader.GetAudio(audio).audio;
}
