void Awake()
{
selectorImage = selector.GetComponent<Image>();
selectorColor = selectorImage.color;
selectorColor.a = unSelectedAlpha;
selectorImage.color = selectorColor;
audioLoader = GetComponent<AudioLoader>();
}
void Awake()
{
audioLoader = GetComponent<AudioLoader>();
gameManager = GameObject.FindGameObjectWithTag("GameManager").GetComponent<GameManager>();
buttonImage = GetComponent<Image>();
buttonColor = buttonImage.color;
buttonColor.a = unSelectedAlpha;
buttonImage.color = buttonColor;
}
// Use this for initialization
public void Start() {
currentHitPoints = maxHitPoints;
if (currentHitPoints > 0) {
if (textures[currentHitPoints] != null) {
GetComponent<Renderer>().material.mainTexture = textures[currentHitPoints];
}
}
audioLoader = GetComponent<AudioLoader>();
}
// Use this for initialization
void Start() {
audioLoader = GetComponent<AudioLoader>();
checkPointSound = audioLoader.GetSound("CheckPoint");
if (!isActive)
{
vortex.Hide();
}
}
// Use this for initialization
void Start() {
standingColl.enabled = true;
crouchingColl.enabled = false;
lastYCoord = -10000.0f;
lastPosition = transform.position;
audioLoader = GetComponent<AudioLoader>();
jumpSound = audioLoader.GetSound("Jump");
pushSound = audioLoader.GetSound("Push");
step0Sound = audioLoader.GetSound("Step0");
step1Sound = audioLoader.GetSound("Step1");
}
// Use this for initialization
void Start() {
audioLoader = GetComponent<AudioLoader>();
changeCharacterSound = audioLoader.GetSound("ChangeCharacter");
activeCheckPoint.ActivateMuted();
activeCharacter = characterList[0];
activeCharacter.GetComponent<CharacterStatus>().playerParticles.IntensifyColor();
if (ActiveCharacterChangedEvent != null) {
ActiveCharacterChangedEvent(activeCharacter);
}
}
// Use this for initialization
new void Start () {
//Inicializacion basica del manager
base.Start();
audioLoader = GetComponent<AudioLoader>();
successSound = audioLoader.GetSound("Success");
failSound = audioLoader.GetSound("Fail");
//Inicializacion del mapa de estado de objetos a false
usablesState = new Dictionary<UsableObject, bool>();
foreach(UsableObject o in usables)
{
usablesState.Add(o, o.onUse);
}
}
/*
public void OnEnable() {
if(hasFadeCutScene) {
ActivableFade.FadeInOutEvent += OpenDoorCutScene;
}
}
public void OnDisable() {
if(hasFadeCutScene) {
ActivableFade.FadeInOutEvent -= OpenDoorCutScene;
}
}
*/
// Use this for initialization
void Start()
{
//Si se va a mostrar un cutscene
cutScene = GetComponent<CutScene>();
/*
if (hasFadeCutScene) {
activableFade = GetComponent<ActivableFade>();
}
*/
audioLoader = GetComponent<AudioLoader>();
if(audioLoader) {
openSound = audioLoader.GetSound("Open");
closeSound = audioLoader.GetSound("Close");
}
//Se calcula un offset ( distancia a la que se movera) en funcion al tamaño y direccion de apertura
Vector3 size = transform.localScale*4.2f;//REVISAR!!!!!!!!!!!!!!!!!!!//GetComponent<Renderer>().bounds.size;
switch (openDirection)
{
case Direction.Down:
offset = new Vector3(0, -size.y, 0);
break;
case Direction.Up:
offset = new Vector3(0, size.y, 0);
break;
case Direction.Left:
offset = new Vector3(-size.z, 0, 0);
break;
case Direction.Right:
offset = new Vector3(size.z, 0, 0);
break;
}
//Se guara la posicion final de la puerta cuando este abierta
endPosition = startPosition + offset;
}
/// <summary>
/// Es necesario llamar a esta funcion desde los scripts que heredan mediante base.Start
/// </summary>
public void Start() {
activables = new List<IActivable>();
//Se guarda la referencia al script Activable
foreach (GameObject target in targets) {
activables.Add(target.GetComponent<IActivable>());
}
//Si no tiene detector de uso, se asume que se puede usar desde cualquier posicion
if (GetComponentInChildren<TooltipDetector>() == null) {
canUse = true;
}
audioLoader = GetComponent<AudioLoader>();
if (type.Equals(UsableTypes.Timed)) {
timeSound = audioLoader.GetSound("TickTack");
fastTimeSound = audioLoader.GetSound("FastTickTack");
}
}
// Use this for initialization
void Start()
{
//Si se va a mostrar un cutscene
cutScene = GetComponent<CutScene>();
audioLoader = GetComponent<AudioLoader>();
if(audioLoader) {
activationSound = audioLoader.GetSound("Activation");
deActivationSound = audioLoader.GetSound("Deactivation");
}
//Se calcula un offset ( distancia a la que se movera) en funcion al tamaño y direccion de apertura
//Vector3 size = transform.localScale;//GetComponent<Renderer>().bounds.size;
switch (openDirection)
{
case Direction.Down:
offset = new Vector3(0, -movement, 0);
break;
case Direction.Up:
offset = new Vector3(0, movement, 0);
break;
case Direction.Left:
offset = new Vector3(-movement, 0, 0);
break;
case Direction.Right:
offset = new Vector3(movement, 0, 0);
break;
}
}
public override void Init()
{
filePath = Def.Get <string>("filePath");
volume = Def.Get("volume", 1f);
string format = Def.Get("format", "OGGVORBIS");
if (!Enum.TryParse <AudioType>(format.Trim(), true, out var formatEnum))
{
Core.Error($"Failed to parse audio format '{format}'.");
Array arr = Enum.GetValues(typeof(AudioType));
object[] args = arr.Cast <object>().ToArray();
Core.Error($"Valid values are: {string.Join(", ", args)}");
Core.Error("Note: .mp3 is NOT SUPPORTED. I recommend using .ogg (OGGVORBIS) or .wav (WAV)");
Remove();
return;
}
// Resolve the file path.
ModContentPack mcp = Def.modContentPack;
if (mcp == null)
{
string[] split = filePath.Split('/');
split[0] = split[0].ToLowerInvariant();
Core.Warn($"Song player program def '{Def.defName}' has been added by a patch operation. Attempting to resolve filepath...");
var found = LoadedModManager.RunningModsListForReading.FirstOrFallback(mod => mod.PackageId.ToLowerInvariant() == split[0]);
if (found == null)
{
Core.Error($"Failed to resolve mod folder path from id '{split[0]}'. See below for how to solve this issue.");
Core.Error("If you mod's package ID is 'my.mod.name' and your song file is in 'MyModFolder/Songs/Song.mp3' then the correct filePath would be 'my.mod.name/Songs/Song.mp3'");
Remove();
return;
}
Core.Warn("Successfully resolved file path.");
mcp = found;
}
filePath = Path.Combine(mcp.RootDir, filePath);
if (clipCache.TryGetValue(filePath, out var clip))
{
FlagLoadedForClip(clip);
}
else
{
Task.Run(async() =>
{
try
{
Core.Log($"Loading '{filePath}' as {formatEnum} ...");
var c = await AudioLoader.TryLoadAsync(filePath, formatEnum);
clipToAdd = c; // Push to main thread, see Tick()
Core.Log("Done");
}
catch (Exception e)
{
Core.Error($"Failed loading song clip from '{filePath}' in format {formatEnum}", e);
Remove();
}
});
}
string msg = "DSC.NowPlaying".Translate(Def.Get("credits", "Unknown"));
Messages.Message(msg, MessageTypeDefOf.PositiveEvent);
}
private void Start()
{
_audioLoader = GetComponent <AudioLoader>();
}
void Awake()
{
AudioLoader.instance = this;
}
protected override void InitializeScene()
{
Mesh bgBox = MeshLoader.FileToMesh("models/cube_flat.obj");
ShaderProgram.TryCreate(new Dictionary <ShaderType, string>
{
{ ShaderType.FragmentShader, "shader/UITextRender.fs" },
{ ShaderType.VertexShader, "shader/UIRender.vs" }
}, out ShaderProgram textShader);
ShaderProgram.TryCreate(new Dictionary <ShaderType, string>
{
{ ShaderType.FragmentShader, "shader/texture.fs" },
{ ShaderType.VertexShader, "shader/texture.vs" }
}, out ShaderProgram shader);
DebugConsoleComponent dbg = DebugConsoleComponent.CreateConsole().GetComponent <DebugConsoleComponent>();
dbg.AddCommand("mov", cmd_ChangeCameraPos);
dbg.AddCommand("rot", cmd_ChangeCameraRot);
dbg.AddCommand("reload", cmd_ReLoadScene);
dbg.AddCommand("next", cmd_NextScene);
dbg.AddCommand("lookat", cmd_LookAtAudioSource);
GameEngine.Instance.CurrentScene.Add(dbg.Owner);
GameObject bgObj = new GameObject(Vector3.UnitY * -3, "BG");
bgObj.Scale = new Vector3(25, 1, 25);
bgObj.AddComponent(new MeshRendererComponent(shader, bgBox,
TextureLoader.FileToTexture("textures/ground4k.png"), 1));
GameEngine.Instance.CurrentScene.Add(bgObj);
BasicCamera c = new BasicCamera(
Matrix4.CreatePerspectiveFieldOfView(MathHelper.DegreesToRadians(75f),
GameEngine.Instance.Width / (float)GameEngine.Instance.Height, 0.01f, 1000f), Vector3.Zero);
c.Translate(new Vector3(0, 4, 0));
_camLookCommandComponent = new LookAtComponent();
c.AddComponent(_camLookCommandComponent);
_sourceCube = new GameObject(Vector3.UnitZ * -5, "Audio Source");
Mesh sourceCube = MeshLoader.FileToMesh("models/cube_flat.obj");
AudioSourceComponent source = new AudioSourceComponent();
_sourceCube.AddComponent(source);
_sourceCube.AddComponent(new RotateAroundComponent());
_sourceCube.AddComponent(new MeshRendererComponent(shader, sourceCube,
TextureLoader.FileToTexture("textures/ground4k.png"), 1));
if (!AudioLoader.TryLoad("sounds/test_mono_16.wav", out AudioFile clip))
{
Console.ReadLine();
}
source.Clip = clip;
source.Looping = true;
source.Play();
GameEngine.Instance.CurrentScene.Add(_sourceCube);
AudioListener listener = new AudioListener();
c.AddComponent(listener);
GameEngine.Instance.CurrentScene.Add(c);
GameEngine.Instance.CurrentScene.SetCamera(c);
}
public static GameObject[] CreatePlayer(Vector3 position, BasicCamera cam)
{
Mesh mouseTargetModel = MeshLoader.FileToMesh("assets/models/sphere_smooth.obj");
GameObject mouseTarget = new GameObject(Vector3.UnitY * -3, "BG");
mouseTarget.Scale = new Vector3(1, 1, 1);
mouseTarget.AddComponent(new LitMeshRendererComponent(DefaultFilepaths.DefaultLitShader, mouseTargetModel,
Prefabs.White, 1));
Mesh playerModel = MeshLoader.FileToMesh("assets/models/sphere_smooth.obj");
Mesh headModel = MeshLoader.FileToMesh("assets/models/cube_flat.obj");
Mesh bullet = MeshLoader.FileToMesh("assets/models/cube_flat.obj");
GameObject player = new GameObject(new Vector3(0, 10, 0), "Player");
GameObject playerH = new GameObject(new Vector3(0, 10, 0), "PlayerHead");
GameObject lightS = new GameObject(Vector3.UnitY * 2f, "Light");
playerH.Add(lightS);
lightS.AddComponent(new LightComponent()
{
AmbientContribution = 0f
});
lightS.LocalPosition = Vector3.UnitY * 14f;
//Movement for camera
OffsetConstraint cameraController = new OffsetConstraint {
Damping = 0, MoveSpeed = 2
};
cameraController.Attach(player, new Vector3(0, 15, 5));
cam.AddComponent(cameraController);
//Rotation for Player Head depending on mouse position
cam.AddComponent(new CameraRaycaster(mouseTarget, playerH));
//Movement for Player Head
OffsetConstraint connection = new OffsetConstraint()
{
Damping = 0, //Directly over the moving collider, no inertia
MoveSpeed = 20, //Even less inertia by moving faster in general
};
connection.Attach(player, Vector3.UnitY * 1);
playerH.AddComponent(connection);
playerH.Scale = new Vector3(0.6f);
playerH.AddComponent(new LitMeshRendererComponent(DefaultFilepaths.DefaultLitShader, headModel,
TextureLoader.FileToTexture("assets/textures/playerHead.png"), 1));
//Player Setup
Collider collider = new Collider(new Sphere(Vector3.Zero, 1, 10), LayerManager.NameToLayer("physics"));
collider.PhysicsCollider.PositionUpdateMode = PositionUpdateMode.Continuous;
collider.PhysicsCollider.Material = new Material(1.5f, 1.5f, 0);
collider.PhysicsCollider.LinearDamping = 0.99f;
player.AddComponent(collider);
player.AddComponent(new LitMeshRendererComponent(DefaultFilepaths.DefaultLitShader, playerModel,
TextureGenerator.GetPlayerTexture(), 1));
AudioSourceComponent source = new AudioSourceComponent();
AudioLoader.TryLoad("assets/audio/ShootSound.wav", out ShootSound);
AudioLoader.TryLoad("assets/audio/ShootSound2.wav", out ShootSound2);
AudioLoader.TryLoad("assets/audio/SpawnSound.wav", out SpawnSound);
AudioLoader.TryLoad("assets/audio/JumpSound.wav", out JumpSound);
source.Clip = SpawnSound;
source.Play();
source.UpdatePosition = false;
source.Gain = 0.5f;
player.AddComponent(source);
player.AddComponent(new PlayerController(playerH, bullet,
TextureLoader.ColorToTexture(Color.Red), DefaultFilepaths.DefaultLitShader, 650, false, source));
player.LocalPosition = position;
GameObject playerUI = new GameObject("PlayerHUD");
playerUI.AddComponent(new PlayerHUD());
return(new[] { player, playerH, playerUI });
}
// Use this for initialization
void Start()
{
_al = GetComponent <AudioLoader>();
_al.LoadSong(PlayerPrefs.GetString("Song"));
}
public static List <Uri> LoadSongs()
{
return(AudioLoader.LoadSongs());
}
protected internal override SoundEffect Read(
ContentReader input, SoundEffect existingInstance)
{
#region Old XNA spec
// XNB format for SoundEffect...
//
// Byte [format size] Format WAVEFORMATEX structure
// UInt32 Data size
// Byte [data size] Data Audio waveform data
// Int32 Loop start In bytes (start must be format block aligned)
// Int32 Loop length In bytes (length must be format block aligned)
// Int32 Duration In milliseconds
// The header containss the WAVEFORMATEX header structure
// defined as the following...
//
// WORD wFormatTag; // byte[0] +2
// WORD nChannels; // byte[2] +2
// DWORD nSamplesPerSec; // byte[4] +4
// DWORD nAvgBytesPerSec; // byte[8] +4
// WORD nBlockAlign; // byte[12] +2
// WORD wBitsPerSample; // byte[14] +2
// WORD cbSize; // byte[16] +2
#endregion
// We let the sound effect deal with parsing this based
// on what format the audio data actually is.
int headerSize = input.ReadInt32();
byte[] header = input.ReadBytes(headerSize);
int loopStart = input.ReadInt32();
int loopLength = input.ReadInt32();
var duration = input.ReadObject <TimeSpan>();
SoundEffect effect;
int rawSize = input.ReadInt32();
short format = BinaryPrimitives.ReadInt16LittleEndian(header);
SoundEffect CreateSoundEffect(RecyclableBuffer buffer)
{
var data = buffer.AsSpan(0, buffer.BaseLength);
return(new SoundEffect(header, data, duration, loopStart, loopLength)
{
// Store the original asset name for debugging later.
Name = input.AssetName
});
}
if (format == 1)
{
using (var data = AudioLoader.Load(
input.BaseStream, out ALFormat alFormat, out _, out _, out _, out _, out _, out _))
{
if (alFormat == ALFormat.MonoFloat32 || alFormat == ALFormat.StereoFloat32)
{
BinaryPrimitives.WriteInt16LittleEndian(header, 3);
}
// data gets uploaded synchronously
effect = CreateSoundEffect(data);
}
}
else
{
using (var data = RecyclableBuffer.ReadBytes(
input.BaseStream, rawSize, nameof(SoundEffectReader)))
effect = CreateSoundEffect(data);
}
return(effect);
}
// Use this for references
void Awake() {
characterStatus = GetComponent<CharacterStatus>();
characterMovement = GetComponent<CharacterMovement>();
audioLoader = GetComponent<AudioLoader>();
}
private static void Render(Settings settings, AudioLoader loader)
{
if (settings.OutputFile != null)
{
// Emit normalized data to a WAV file for later mixing
if (settings.MasterAudioFile == null && !settings.NoMasterMix)
{
settings.MasterAudioFile = settings.OutputFile + ".wav";
loader.MixToFile(settings.MasterAudioFile, !settings.NoMasterMixReplayGain);
}
}
Console.WriteLine("Generating background image...");
var backgroundImage = new BackgroundRenderer(settings.Width, settings.Height, ParseColor(settings.BackgroundColor));
if (settings.BackgroundImageFile != null)
{
using (var bm = Image.FromFile(settings.BackgroundImageFile))
{
backgroundImage.Add(new ImageInfo(bm, ContentAlignment.MiddleCenter, true, DockStyle.None, 0.5f));
}
}
if (settings.LogoImageFile != null)
{
using (var bm = Image.FromFile(settings.LogoImageFile))
{
backgroundImage.Add(new ImageInfo(bm, ContentAlignment.BottomRight, false, DockStyle.None, 1));
}
}
if (settings.VgmFile != null)
{
var gd3 = Gd3Tag.LoadFromVgm(settings.VgmFile);
var gd3Text = gd3.ToString();
if (gd3Text.Length > 0)
{
backgroundImage.Add(new TextInfo(gd3Text, settings.Gd3Font, settings.Gd3FontSize, ContentAlignment.BottomLeft, FontStyle.Regular,
DockStyle.Bottom, ParseColor(settings.Gd3FontColor)));
}
}
var renderer = new WaveformRenderer
{
BackgroundImage = backgroundImage.Image,
Columns = settings.Columns,
FramesPerSecond = settings.FramesPerSecond,
Width = settings.Width,
Height = settings.Height,
SamplingRate = loader.SampleRate,
RenderedLineWidthInSamples = settings.ViewWidthMs * loader.SampleRate / 1000,
RenderingBounds = backgroundImage.WaveArea
};
if (settings.GridLineWidth > 0)
{
renderer.Grid = new WaveformRenderer.GridConfig
{
Color = ParseColor(settings.GridColor),
Width = settings.GridLineWidth,
DrawBorder = settings.GridBorder
};
}
if (settings.ZeroLineWidth > 0)
{
renderer.ZeroLine = new WaveformRenderer.ZeroLineConfig
{
Color = ParseColor(settings.ZeroLineColor),
Width = settings.ZeroLineWidth
};
}
// Add the data to the renderer
foreach (var channel in loader.Data)
{
renderer.AddChannel(new Channel(
channel.Samples,
ParseColor(settings.LineColor),
settings.LineWidth,
GuessChannelName(channel.Filename),
CreateTriggerAlgorithm(settings.TriggerAlgorithm),
settings.TriggerLookahead));
}
if (settings.ChannelLabelsFont != null)
{
renderer.ChannelLabels = new WaveformRenderer.LabelConfig
{
Color = ParseColor(settings.ChannelLabelsColor),
FontName = settings.ChannelLabelsFont,
Size = settings.ChannelLabelsSize
};
}
var outputs = new List <IGraphicsOutput>();
if (settings.FfMpegPath != null)
{
Console.WriteLine("Adding FFMPEG renderer...");
outputs.Add(new FfmpegOutput(settings.FfMpegPath, settings.OutputFile, settings.Width, settings.Height, settings.FramesPerSecond, settings.FfMpegExtraOptions, settings.MasterAudioFile));
}
if (settings.PreviewFrameskip > 0)
{
Console.WriteLine("Adding preview renderer...");
outputs.Add(new PreviewOutput(settings.PreviewFrameskip));
}
try
{
Console.WriteLine("Rendering...");
var sw = Stopwatch.StartNew();
renderer.Render(outputs);
sw.Stop();
int numFrames = (int)(loader.Length.TotalSeconds * settings.FramesPerSecond);
Console.WriteLine($"Rendering complete in {sw.Elapsed:g}, average {numFrames / sw.Elapsed.TotalSeconds:N} fps");
}
catch (Exception ex)
{
// Should mean it was cancelled
Console.WriteLine($"Rendering cancelled: {ex.Message}");
}
finally
{
foreach (var graphicsOutput in outputs)
{
graphicsOutput.Dispose();
}
}
}
// Use this for initialization
void Start() {
audioLoader = GetComponent<AudioLoader>();
messagesSfxs = new ArrayList();
//Rellenamos el array de efectos de sonido
messagesSfxs.Add(audioLoader.GetSound("Message1"));
messagesSfxs.Add(audioLoader.GetSound("Message2"));
messagesSfxs.Add(audioLoader.GetSound("Message3"));
messagesSfxs.Add(audioLoader.GetSound("Message4"));
messagesSfxs.Add(audioLoader.GetSound("Message5"));
//Estado inicial
messageState = State.NoMessage;
messages = new ArrayList();
//Se inicializa la velocidad a la velocidad normal
letterSpeed = normalLetterSpeed;
isConversation = false;
//shownImg = null;
//Se cargan los mensajes desde fichero
FillMessages();
}
// Use this for initialization
void Start() {
// Inicialización
Initialization();
//Se saca el objeto del padre para poder añadirlo como hijo a nuevos elementos
transform.parent = null;
// Obtención sonidos
audioLoader = GetComponent<AudioLoader>();
resurrectSound = audioLoader.GetSound("Resurrect");
dieSound = audioLoader.GetSound("Die");
sacrificeSound = audioLoader.GetSound("Sacrifice");
pushSound = audioLoader.GetSound("Push");
}
public void SetLoader(AudioLoader loader)
{
this.loader = loader;
}
void init () {
if (SingletonUtil.TryInit(ref _instance, this, gameObject)) {
_loader = new AudioLoader(PATH);
_fileList = _loader.Load();
initFileDictionary(_fileList);
addAudioEvents();
subscribeEvents();
}
}
// Use this for initialization
void Start () {
audioLoader = GetComponent<AudioLoader>();
shooter = GetComponent<Shooter>();
//Se inicializa el estado de las charcas disponibles
for (int i = 0; i < poolList.Length; i++)
{
availablePools.Add(poolList[i].GetComponent<Pool>());
availablePools[i].SetKappa(this);
}
//Se inicializa la lista de jugadores a tiro
playersOnSight = new List<GameObject>();
//Se inicializa la posicion y los limites de altura
maxHeight = transform.position.y;
transform.position -= new Vector3(0, divingDepth, 0);
minHeight = transform.position.y;
//Comienza su comportamiento apareciendo
Invoke("StartAppearing", divingTime);
}
public void Set(AudioClips audio)
{
_audioSrc.clip = AudioLoader.GetAudio(audio).audio;
}
public static Uri BuildUri(string fileName, bool music)
{
return(AudioLoader.BuildUri(fileName, music));
}
// Must be colled to setup the class's functionality
void Init () {
// Singleton method returns a bool depending on whether this object is the instance of the class
if (SingletonUtil.TryInit (ref Instance, this, gameObject)) {
loader = new AudioLoader (path);
fileList = loader.Load ();
fileList.Init ();
InitFileDictionary (fileList);
AddAudioEvents ();
SubscribeEvents ();
if (isAudioListener) {
AddAudioListener ();
}
initCyclingAudio ();
} else {
//this = Instance;
}
}
public void PlayMusic()
{
AudioLoader.LoadSong(songData.GetRootFolder() + "\\" + songData.RequestParam("MUSIC"));
WaitingForFileLoad = true;
}
public async UniTask <AudioClip> LoadByWebRequest(string filename, AudioType audioType = AudioType.OGGVORBIS)
{
originalClip = clip = await AudioLoader.LoadByWebRequest(filename, audioType);
return(originalClip);
}
