Mirrors/HeavenStudio
1
0
Fork 0
mirror of https://github.com/RHeavenStudio/HeavenStudio.git synced 2025-06-12 08:57:37 +02:00
Code Issues Packages Projects Releases Wiki Activity

Tunnel tunnels (#577)

Browse Source 
* tunnel tunnel

tunnel

* tunnel messes with the volume

* tempo finder can now be reset by waiting

now uses the conductor's time source if it exists and is playing

* wip anims

* Animations Finished

* add tunnel sound

* tunnel shader

fix the left sound

* add pre-sliced BG assets

---------

Co-authored-by: Seanski2 <seanbenedit@gmail.com>
This commit is contained in:
minenice55
2023-11-24 17:59:34 -05:00
committed by GitHub
parent 0b6ad7bdca
commit 13db943ab5
62 changed files with 7323 additions and 1270 deletions
Download Patch File Download Diff File Expand all files Collapse all files

172
Assets/Scripts/Games/Tunnel/Tunnel.cs
View File

@ -1,6 +1,6 @@
using DG.Tweening;
using NaughtyBezierCurves;
using HeavenStudio.Util;
using HeavenStudio.Util;
using System;
using System.Collections.Generic;
using UnityEngine;
@ -14,23 +14,37 @@ namespace HeavenStudio.Games.Loaders
{
return new Minigame("tunnel", "Tunnel \n<color=#eb5454>[WIP]</color>", "c00000", false, false, new List<GameAction>()
{
new GameAction("cowbell", "Cowbell")
new GameAction("cowbell", "Start Cowbell")
{
preFunction = delegate { Tunnel.PreStartCowbell(eventCaller.currentEntity.beat, eventCaller.currentEntity.length); },
defaultLength = 1f,
resizable = false,
},
new GameAction("tunnel", "Tunnel")
{
function = delegate { if (Tunnel.instance != null) {
var e = eventCaller.currentEntity;
Tunnel.instance.StartTunnel(e.beat, e.length, e["volume"] / 100f, e["duration"]);
} },
defaultLength = 4f,
resizable = true,
parameters = new List<Param>()
{
new Param("duration", new EntityTypes.Float(0, 8, 2), "Fade Duration", "The duration of the volume fade in beats"),
new Param("volume", new EntityTypes.Float(0, 200, 10), "Volume", "The volume to fade to"),
}
},
new GameAction("countin", "Count In")
{
preFunction = delegate { Tunnel.CountIn(eventCaller.currentEntity.beat, eventCaller.currentEntity.length); },
defaultLength = 4f,
preFunction = delegate { Tunnel.CountIn(eventCaller.currentEntity.beat, eventCaller.currentEntity.length); },
defaultLength = 4f,
resizable = true,
}
},
new List<string>() {"ntr", "keep"},
new List<string>() { "ntr", "keep" },
"ntrtunnel", "en",
new List<string>() {"en"}
new List<string>() { "en" }
);
}
}
@ -40,36 +54,46 @@ namespace HeavenStudio.Games
{
public class Tunnel : Minigame
{
const double PostTunnelScrnTime = 0.25;
public static Tunnel instance { get; set; }
[Header("Backgrounds")]
public SpriteRenderer fg;
public SpriteRenderer bg;
[SerializeField] Transform bg;
[SerializeField] float bgScrollTime;
Tween bgColorTween;
Tween fgColorTween;
[SerializeField] Material tunnelLightMaterial;
[SerializeField] Color tunnelTint;
[SerializeField] Color tunnelScreen;
[SerializeField] GameObject tunnelWall;
[SerializeField] SpriteRenderer tunnelWallRenderer;
[SerializeField] float tunnelChunksPerSec;
[SerializeField] float tunnelWallChunkSize;
Vector3 tunnelStartPos;
Sound tunnelSoundRight, tunnelSoundMiddle, tunnelSoundLeft;
[Header("References")]
public GameObject frontHand;
[SerializeField] GameObject frontHand;
[Header("Animators")]
public Animator cowbellAnimator;
public Animator driverAnimator;
[SerializeField] Animator cowbellAnimator;
[SerializeField] Animator driverAnimator;
[Header("Curves")]
public BezierCurve3D handCurve;
[SerializeField] BezierCurve3D handCurve;
GameEvent cowbell = new GameEvent();
public GameEvent cowbell = new GameEvent();
float bgStartX;
float fadeDuration = 2f;
double tunnelStartTime = double.MinValue;
double tunnelEndTime = double.MinValue;
double lastCowbell = double.MaxValue;
float handStart;
float handProgress;
bool inTunnel;
public int driverState;
public float handStart;
public float handProgress;
public bool started;
public struct QueuedCowbell
{
public double beat;
@ -80,6 +104,7 @@ namespace HeavenStudio.Games
private void Awake()
{
instance = this;
tunnelStartPos = new Vector3(tunnelWallChunkSize, 0, 0);
}
void OnDestroy()
@ -89,22 +114,30 @@ namespace HeavenStudio.Games
{
evt.Disable();
}
if (Conductor.instance != null && !(Conductor.instance.isPlaying || Conductor.instance.isPaused))
{
Conductor.instance.FadeMinigameVolume(Conductor.instance.songPositionInBeatsAsDouble, 0, 1);
tunnelLightMaterial.SetColor("_Color", Color.white);
tunnelLightMaterial.SetColor("_AddColor", Color.black);
tunnelSoundRight?.Stop();
tunnelSoundMiddle?.Stop();
tunnelSoundLeft?.Stop();
}
}
private void Start()
{
driverState = 0;
handStart = -1f;
tunnelWall.SetActive(false);
}
private void Update()
{
var cond = Conductor.instance;
//update hand position
handProgress = Math.Min(Conductor.instance.songPositionInBeats - handStart, 1);
frontHand.transform.position = handCurve.GetPoint(EasingFunction.EaseOutQuad(0, 1, handProgress));
if (!cond.isPlaying || cond.isPaused)
{
@ -125,16 +158,33 @@ namespace HeavenStudio.Games
queuedInputs.Clear();
}
}
if (lastCowbell + 1 <= cond.songPositionInBeatsAsDouble)
{
lastCowbell++;
ScheduleInput(lastCowbell, 1, InputAction_BasicPress, CowbellSuccess, CowbellMiss, CowbellEmpty);
}
// bg.localPosition = new Vector3(bgStartX - (2 * bgStartX * (((float)Time.realtimeSinceStartupAsDouble % bgScrollTime) / bgScrollTime)), 0, 0);
if (tunnelWall.activeSelf)
{
tunnelWall.transform.localPosition = tunnelStartPos - new Vector3(tunnelChunksPerSec * tunnelWallChunkSize * (float)(cond.songPositionAsDouble - tunnelStartTime), 0, 0);
}
if (inTunnel && cond.songPositionAsDouble >= tunnelEndTime + PostTunnelScrnTime)
{
cond.FadeMinigameVolume(cond.GetBeatFromSongPos(tunnelEndTime + PostTunnelScrnTime), fadeDuration, 1);
tunnelLightMaterial.SetColor("_Color", Color.white);
tunnelLightMaterial.SetColor("_AddColor", Color.black);
inTunnel = false;
}
}
public void HitCowbell()
{
SoundByte.PlayOneShot("count-ins/cowbell");
handStart = Conductor.instance.songPositionInBeats;
cowbellAnimator.Play("Shake",-1,0);
cowbellAnimator.Play("Shake", -1, 0);
}
public static void PreStartCowbell(double beat, float length)
@ -151,18 +201,14 @@ namespace HeavenStudio.Games
public void StartCowbell(double beat, float length)
{
started = true;
for(int i = 0; i < length; i++)
{
ScheduleInput(beat, i, InputAction_BasicPress, CowbellSuccess, CowbellMiss, CowbellEmpty);
}
lastCowbell = beat - 1;
ScheduleInput(lastCowbell, 1, InputAction_BasicPress, CowbellSuccess, CowbellMiss, CowbellEmpty);
}
public void CowbellSuccess(PlayerActionEvent caller, float state)
{
HitCowbell();
//print(state);
if(Math.Abs(state) >= 1f)
if (Math.Abs(state) >= 1f)
{
driverAnimator.Play("Disturbed", -1, 0);
@ -171,33 +217,22 @@ namespace HeavenStudio.Games
{
driverAnimator.Play("Idle", -1, 0);
}
}
public void CowbellMiss(PlayerActionEvent caller)
{
//HitCowbell();
driverAnimator.Play("Angry1", -1, 0);
}
public void CowbellEmpty(PlayerActionEvent caller)
{
//HitCowbell();
}
public void CowbellEmpty(PlayerActionEvent caller) { }
public static void CountIn(double beat, float length)
{
List<MultiSound.Sound> cuelist = new List<MultiSound.Sound>();
for (int i = 0; i < length; i++)
{
if(i % 2 == 0)
if (i % 2 == 0)
{
//Jukebox.PlayOneShotGame("tunnel/en/one", beat+i);
//print("cueing one at " + (beat + i));
@ -209,13 +244,52 @@ namespace HeavenStudio.Games
//print("cueing two at " + (beat + i));
cuelist.Add(new MultiSound.Sound("tunnel/en/two", beat + i));
}
}
MultiSound.Play(cuelist.ToArray(), forcePlay: true);
}
public void StartTunnel(double beat, double length, float volume = 0.1f, float fadeDuration = 2f)
{
Conductor cond = Conductor.instance;
if (cond.songPositionAsDouble < tunnelEndTime + PostTunnelScrnTime)
{
return;
}
double targetBeat = beat + length;
tunnelStartTime = cond.GetSongPosFromBeat(beat);
tunnelEndTime = cond.GetSongPosFromBeat(targetBeat);
// tunnel chunks can be divided into quarters
double durationSec = Math.Ceiling((tunnelEndTime - tunnelStartTime) * 4 * tunnelChunksPerSec) * 0.25 / tunnelChunksPerSec;
tunnelWallRenderer.size = new Vector2((float)durationSec * tunnelWallChunkSize * tunnelChunksPerSec, 13.7f);
tunnelWall.transform.localPosition = tunnelStartPos;
tunnelWall.SetActive(true);
this.fadeDuration = fadeDuration;
cond.FadeMinigameVolume(beat, fadeDuration, volume);
tunnelSoundRight?.Stop();
tunnelSoundMiddle?.Stop();
tunnelSoundLeft?.Stop();
tunnelSoundRight = SoundByte.PlayOneShotGame("tunnel/tunnelRight", beat, looping: true);
tunnelSoundMiddle = SoundByte.PlayOneShotGame("tunnel/tunnelMiddle", beat + (6 / 48f), looping: true);
tunnelSoundLeft = SoundByte.PlayOneShotGame("tunnel/tunnelLeft", beat + (12 / 48f), looping: true);
double tunnelEnd = cond.GetBeatFromSongPos(tunnelEndTime + PostTunnelScrnTime);
tunnelSoundRight.SetLoopParams(tunnelEnd, 0.1);
tunnelSoundMiddle.SetLoopParams(tunnelEnd + (6 / 48f), 0.1);
tunnelSoundLeft.SetLoopParams(tunnelEnd + (12 / 48f), 0.25);
BeatAction.New(instance, new List<BeatAction.Action>()
{
new BeatAction.Action(cond.GetBeatFromSongPos(tunnelStartTime + 0.25), delegate {
tunnelLightMaterial.SetColor("_Color", tunnelTint);
tunnelLightMaterial.SetColor("_AddColor", tunnelScreen);
}),
});
inTunnel = true;
}
}
}