825 lines
34 KiB
C#
825 lines
34 KiB
C#
using HeavenStudio.Util;
|
|
using System;
|
|
using System.Linq;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using Jukebox;
|
|
|
|
namespace HeavenStudio.Games.Loaders
|
|
{
|
|
using static Minigames;
|
|
public static class RvlTapTroupeLoader
|
|
{
|
|
public static Minigame AddGame(EventCaller eventCaller)
|
|
{
|
|
return new Minigame("tapTroupe", "Tap Troupe", "999999", false, false, new List<GameAction>()
|
|
{
|
|
new GameAction("bop", "Bop")
|
|
{
|
|
function = delegate {var e = eventCaller.currentEntity; TapTroupe.instance.Bop(e.beat, e.length, e["bop"], e["bopAuto"]); },
|
|
resizable = true,
|
|
parameters = new List<Param>()
|
|
{
|
|
new Param("bop", true, "Bop", "Toggle if the tall tappers should bop for the duration of this event."),
|
|
new Param("bopAuto", false, "Bop (Auto)", "Toggle if the tall tappers should automatically bop until another Bop event is reached.")
|
|
}
|
|
},
|
|
new GameAction("stepping", "Stepping")
|
|
{
|
|
preFunction = delegate { var e = eventCaller.currentEntity; TapTroupe.PreStepping(e.beat, e.length, e["startTap"]); },
|
|
defaultLength = 4f,
|
|
resizable = true,
|
|
parameters = new List<Param>()
|
|
{
|
|
new Param("startTap", false, "Tap Voice Line", "Toggle if the \"Tap!\" voice line should be played on the first tap.")
|
|
}
|
|
},
|
|
new GameAction("tapping", "Tapping")
|
|
{
|
|
preFunction = delegate { var e = eventCaller.currentEntity; TapTroupe.PreTapping(e.beat, e.length, e["okay"], e["okayType"], e["animType"], e["popperBeats"], e["randomVoiceLine"], e["noReady"]); },
|
|
defaultLength = 3f,
|
|
resizable = true,
|
|
parameters = new List<Param>()
|
|
{
|
|
new Param("okay", true, "OK", "Toggle if the tall tappers should say \"OK!\" after successfully tapping.", new List<Param.CollapseParam>()
|
|
{
|
|
new Param.CollapseParam((x, _) => (bool)x, new string[] { "okayType" })
|
|
}),
|
|
new Param("okayType", TapTroupe.OkayType.OkayA, "Type", "Set the version of the voice line the tall tappers should say."),
|
|
new Param("animType", TapTroupe.OkayAnimType.Normal, "Animation", "Set the animation that should be played when the tall tappers say \"OK!\"", new List<Param.CollapseParam>()
|
|
{
|
|
new Param.CollapseParam((x, _) => (int)x == (int)TapTroupe.OkayAnimType.Popper, new string[]{ "popperBeats"})
|
|
}),
|
|
new Param("popperBeats", new EntityTypes.Float(0f, 80f, 2f), "Popper Beats", "Set how many beats it should take for the party popper to pop."),
|
|
new Param("randomVoiceLine", true, "Extra Random Voice Line", "Whether there should be randomly said woos or laughs after the tappers say OK!"),
|
|
new Param("noReady", false, "Mute Ready", "Toggle if the \"Rea-dy!\" cue should be muted.")
|
|
}
|
|
},
|
|
new GameAction("spotlights", "Spotlights")
|
|
{
|
|
function = delegate {var e = eventCaller.currentEntity; TapTroupe.instance.Spotlights(e["toggle"], e["player"], e["middleLeft"], e["middleRight"], e["leftMost"]); },
|
|
defaultLength = 0.5f,
|
|
parameters = new List<Param>()
|
|
{
|
|
new Param("toggle", true, "Darkness", "Toggle if the scene should be dark and the spotlights should appear."),
|
|
new Param("leftMost", false, "Leftmost Spotlight", "Toggle if the leftmost spotlight should be turned on or off."),
|
|
new Param("middleLeft", false, "Middle-Left Spotlight", "Toggle if the middle-left spotlight should be turned on or off."),
|
|
new Param("middleRight", false, "Middle-Right Spotlight", "Toggle if the middle-right spotlight should be turned on or off."),
|
|
new Param("player", true, "Player Spotlight", "Toggle if the player's spotlight should be turned on or off."),
|
|
}
|
|
},
|
|
new GameAction("zoomOut", "Zoom Out")
|
|
{
|
|
function = delegate { TapTroupe.instance.ToggleZoomOut(); },
|
|
defaultLength = 4f,
|
|
resizable = true,
|
|
parameters = new List<Param>()
|
|
{
|
|
new Param("ease", Util.EasingFunction.Ease.EaseOutQuad, "Ease", "Set the easing of the action."),
|
|
},
|
|
},
|
|
new GameAction("tutorialMissFace", "Tutorial Miss Face")
|
|
{
|
|
function = delegate { var e = eventCaller.currentEntity; TapTroupe.instance.ToggleMissFace(e["toggle"]); },
|
|
defaultLength = 0.5f,
|
|
parameters = new List<Param>()
|
|
{
|
|
new Param("toggle", true, "Tutorial Miss Face", "Toggle if the NPC tappers should use the miss face as seen in the original tutorial.")
|
|
}
|
|
}
|
|
},
|
|
new List<string>() {"rvl", "keep"},
|
|
"rvllegs", "en",
|
|
new List<string>() {"en"},
|
|
chronologicalSortKey: 31
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
namespace HeavenStudio.Games
|
|
{
|
|
using Scripts_TapTroupe;
|
|
public class TapTroupe : Minigame
|
|
{
|
|
[Header("Components")]
|
|
[SerializeField] TapTroupeTapper playerTapper;
|
|
[SerializeField] TapTroupeCorner playerCorner;
|
|
[SerializeField] List<TapTroupeTapper> npcTappers = new List<TapTroupeTapper>();
|
|
[SerializeField] List<TapTroupeCorner> npcCorners = new List<TapTroupeCorner>();
|
|
[SerializeField] GameObject spotlightPlayer;
|
|
[SerializeField] GameObject spotlightMiddleLeft;
|
|
[SerializeField] GameObject spotlightMiddleRight;
|
|
[SerializeField] GameObject spotlightLeftMost;
|
|
[SerializeField] GameObject darkness;
|
|
private Animator zoomOutAnim;
|
|
[Header("Properties")]
|
|
private double currentZoomCamBeat;
|
|
private float currentZoomCamLength;
|
|
private Util.EasingFunction.Ease lastEase;
|
|
|
|
private int currentZoomIndex;
|
|
|
|
private List<RiqEntity> allCameraEvents = new List<RiqEntity>();
|
|
private bool keepZoomOut;
|
|
private static List<QueuedSteps> queuedSteps = new List<QueuedSteps>();
|
|
private static List<QueuedTaps> queuedTaps = new List<QueuedTaps>();
|
|
public static bool prepareTap;
|
|
private bool tapping;
|
|
private bool stepping;
|
|
private bool shouldSwitchStep;
|
|
private bool shouldDoSecondBam;
|
|
private bool missedTaps;
|
|
private bool canSpit = true;
|
|
private bool goBop;
|
|
private bool useTutorialMissFace;
|
|
private TapTroupeTapper.TapAnim currentTapAnim;
|
|
public GameEvent bop = new GameEvent();
|
|
public struct QueuedSteps
|
|
{
|
|
public double beat;
|
|
public float length;
|
|
public bool startTap;
|
|
}
|
|
public struct QueuedTaps
|
|
{
|
|
public double beat;
|
|
public float length;
|
|
public bool okay;
|
|
public int okayType;
|
|
public int animType;
|
|
public float popperBeats;
|
|
public bool randomVoiceLine;
|
|
}
|
|
public enum OkayType
|
|
{
|
|
OkayA = 0,
|
|
OkayB = 1,
|
|
OkayC = 2,
|
|
Random = 3
|
|
}
|
|
public enum OkayAnimType
|
|
{
|
|
Normal = 0,
|
|
Popper = 1,
|
|
OkSign = 2,
|
|
Random = 3
|
|
}
|
|
private int stepSound = 1;
|
|
|
|
public static TapTroupe instance;
|
|
|
|
void OnDestroy()
|
|
{
|
|
if (queuedSteps.Count > 0) queuedSteps.Clear();
|
|
if (queuedTaps.Count > 0) queuedTaps.Clear();
|
|
prepareTap = false;
|
|
foreach (var evt in scheduledInputs)
|
|
{
|
|
evt.Disable();
|
|
}
|
|
}
|
|
|
|
public override void OnTimeChange()
|
|
{
|
|
UpdateCameraZoom();
|
|
}
|
|
|
|
void Awake()
|
|
{
|
|
instance = this;
|
|
zoomOutAnim = GetComponent<Animator>();
|
|
var camEvents = EventCaller.GetAllInGameManagerList("tapTroupe", new string[] { "zoomOut" });
|
|
List<RiqEntity> tempEvents = new List<RiqEntity>();
|
|
for (int i = 0; i < camEvents.Count; i++)
|
|
{
|
|
if (camEvents[i].beat + camEvents[i].beat >= Conductor.instance.songPositionInBeatsAsDouble)
|
|
{
|
|
tempEvents.Add(camEvents[i]);
|
|
}
|
|
}
|
|
|
|
allCameraEvents = tempEvents;
|
|
|
|
UpdateCameraZoom();
|
|
}
|
|
|
|
void Update()
|
|
{
|
|
var cond = Conductor.instance;
|
|
if (cond.isPlaying && !cond.isPaused)
|
|
{
|
|
if (cond.ReportBeat(ref bop.lastReportedBeat, bop.startBeat % 1) && goBop)
|
|
{
|
|
BopSingle();
|
|
}
|
|
if (queuedSteps.Count > 0)
|
|
{
|
|
foreach (var step in queuedSteps)
|
|
{
|
|
Stepping(step.beat, step.length, step.startTap);
|
|
}
|
|
queuedSteps.Clear();
|
|
}
|
|
if (queuedTaps.Count > 0)
|
|
{
|
|
foreach (var tap in queuedTaps)
|
|
{
|
|
Tapping(tap.beat, tap.length, tap.okay, tap.okayType, tap.animType, tap.popperBeats, tap.randomVoiceLine);
|
|
BeatAction.New(instance, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(tap.beat - 1.1f, delegate { prepareTap = true; }),
|
|
new BeatAction.Action(tap.beat, delegate { prepareTap = false; })
|
|
});
|
|
}
|
|
queuedTaps.Clear();
|
|
}
|
|
if (PlayerInput.GetIsAction(InputAction_BasicPress) && !IsExpectingInputNow(InputAction_BasicPress))
|
|
{
|
|
if (canSpit && !useTutorialMissFace) SoundByte.PlayOneShotGame("tapTroupe/spit", -1, 1, 0.5f);
|
|
SoundByte.PlayOneShotGame("tapTroupe/miss");
|
|
TapTroupe.instance.ScoreMiss(0.5f);
|
|
foreach (var corner in npcCorners)
|
|
{
|
|
if (useTutorialMissFace)
|
|
{
|
|
corner.SetMissFace(TapTroupeCorner.MissFace.LOL);
|
|
}
|
|
else
|
|
{
|
|
corner.SetMissFace(TapTroupeCorner.MissFace.Spit);
|
|
}
|
|
}
|
|
if (tapping)
|
|
{
|
|
missedTaps = true;
|
|
playerTapper.Tap(currentTapAnim, false, shouldSwitchStep);
|
|
playerCorner.Bop();
|
|
}
|
|
else
|
|
{
|
|
playerTapper.Step(false);
|
|
playerCorner.Bop();
|
|
}
|
|
canSpit = false;
|
|
}
|
|
}
|
|
if (allCameraEvents.Count > 0)
|
|
{
|
|
if (currentZoomIndex < allCameraEvents.Count && currentZoomIndex >= 0)
|
|
{
|
|
if (Conductor.instance.songPositionInBeatsAsDouble >= allCameraEvents[currentZoomIndex].beat)
|
|
{
|
|
UpdateCameraZoom();
|
|
currentZoomIndex++;
|
|
}
|
|
}
|
|
|
|
float normalizedBeat = Conductor.instance.GetPositionFromBeat(currentZoomCamBeat, currentZoomCamLength);
|
|
float normalizedAnimBeat = normalizedBeat * 4;
|
|
|
|
if (normalizedBeat >= 0)
|
|
{
|
|
if (!keepZoomOut)
|
|
{
|
|
GameCamera.AdditionalPosition = new Vector3(0, 0, 0);
|
|
zoomOutAnim.Play("NoZoomOut", 0, 0);
|
|
}
|
|
else
|
|
{
|
|
Util.EasingFunction.Function func = Util.EasingFunction.GetEasingFunction(lastEase);
|
|
if (normalizedBeat > 1)
|
|
GameCamera.AdditionalPosition = new Vector3(0, 30, -100);
|
|
else
|
|
{
|
|
float newPosY = func(0, 30, normalizedBeat);
|
|
float newPosZ = func(0, -100, normalizedBeat);
|
|
GameCamera.AdditionalPosition = new Vector3(0, newPosY, newPosZ);
|
|
}
|
|
if (normalizedAnimBeat > 1)
|
|
{
|
|
zoomOutAnim.DoNormalizedAnimation("ZoomOut", 1f);
|
|
playerTapper.FadeOut(1f);
|
|
foreach (var tapper in npcTappers)
|
|
{
|
|
tapper.FadeOut(1f);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
zoomOutAnim.DoNormalizedAnimation("ZoomOut", normalizedAnimBeat);
|
|
playerTapper.FadeOut(normalizedAnimBeat);
|
|
foreach (var tapper in npcTappers)
|
|
{
|
|
tapper.FadeOut(normalizedAnimBeat);
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
void UpdateCameraZoom()
|
|
{
|
|
if (currentZoomIndex < allCameraEvents.Count && currentZoomIndex >= 0)
|
|
{
|
|
currentZoomCamLength = allCameraEvents[currentZoomIndex].length;
|
|
currentZoomCamBeat = allCameraEvents[currentZoomIndex].beat;
|
|
lastEase = (Util.EasingFunction.Ease)allCameraEvents[currentZoomIndex]["ease"];
|
|
}
|
|
}
|
|
|
|
public void ToggleZoomOut()
|
|
{
|
|
keepZoomOut = true;
|
|
}
|
|
|
|
public static void PreStepping(double beat, float length, bool startTap)
|
|
{
|
|
if (GameManager.instance.currentGame == "tapTroupe")
|
|
{
|
|
TapTroupe.instance.Stepping(beat, length, startTap);
|
|
|
|
}
|
|
else
|
|
{
|
|
queuedSteps.Add(new QueuedSteps { beat = beat, length = length, startTap = startTap });
|
|
}
|
|
}
|
|
|
|
public void Stepping(double beat, float length, bool startTap)
|
|
{
|
|
for (int i = 0; i < length; i++)
|
|
{
|
|
TapTroupe.instance.ScheduleInput(beat - 1, 1 + i, InputAction_BasicPress, TapTroupe.instance.JustStep, TapTroupe.instance.MissStep, TapTroupe.instance.Nothing);
|
|
BeatAction.New(instance, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beat + i, delegate
|
|
{
|
|
TapTroupe.instance.NPCStep();
|
|
SoundByte.PlayOneShotGame("tapTroupe/other1", -1, 1, 0.75f);
|
|
})
|
|
});
|
|
}
|
|
BeatAction.New(instance, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beat - 1, delegate
|
|
{
|
|
if (tapping) return;
|
|
TapTroupe.instance.NPCStep(false, false);
|
|
TapTroupe.instance.playerTapper.Step(false, false);
|
|
TapTroupe.instance.playerCorner.Bop();
|
|
}),
|
|
new BeatAction.Action(beat, delegate { if (startTap) SoundByte.PlayOneShotGame("tapTroupe/startTap"); stepping = true; }),
|
|
new BeatAction.Action(beat + length + 1, delegate { stepping = false; }),
|
|
});
|
|
}
|
|
|
|
public static void PreTapping(double beat, float length, bool okay, int okayType, int animType, float popperBeats, bool randomVoiceLine, bool noReady)
|
|
{
|
|
if (!noReady)
|
|
{
|
|
MultiSound.Play(new MultiSound.Sound[]
|
|
{
|
|
new MultiSound.Sound("tapTroupe/tapReady1", beat - 2f),
|
|
new MultiSound.Sound("tapTroupe/tapReady2", beat - 1f),
|
|
}, forcePlay: true);
|
|
}
|
|
if (GameManager.instance.currentGame == "tapTroupe")
|
|
{
|
|
TapTroupe.instance.Tapping(beat, length, okay, okayType, animType, popperBeats, randomVoiceLine);
|
|
BeatAction.New(instance, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beat - 1.1f, delegate { prepareTap = true; }),
|
|
new BeatAction.Action(beat, delegate { prepareTap = false; })
|
|
});
|
|
}
|
|
else
|
|
{
|
|
queuedTaps.Add(new QueuedTaps { beat = beat, length = length, okay = okay, okayType = okayType, animType = animType, popperBeats = popperBeats, randomVoiceLine = randomVoiceLine });
|
|
}
|
|
}
|
|
|
|
public void Tapping(double beat, float length, bool okay, int okayType, int animType, float popperBeats, bool randomVoiceLine)
|
|
{
|
|
float actualLength = length - 0.5f;
|
|
actualLength -= actualLength % 0.75f;
|
|
bool secondBam = false;
|
|
double finalBeatToSpawn = 0f;
|
|
if (actualLength < 2.25f) actualLength = 2.25f;
|
|
List<MultiSound.Sound> soundsToPlay = new List<MultiSound.Sound>
|
|
{
|
|
new MultiSound.Sound("tapTroupe/tapAnd", beat)
|
|
};
|
|
for (float i = 0; i < actualLength; i += 0.75f)
|
|
{
|
|
string soundToPlay = "bamvoice1";
|
|
string otherSoundToPlay = "other3";
|
|
double beatToSpawn = beat + i + 0.5f;
|
|
if (i + 0.75f >= actualLength)
|
|
{
|
|
soundToPlay = "startTap";
|
|
otherSoundToPlay = "other2";
|
|
beatToSpawn = Math.Ceiling(beat + i);
|
|
finalBeatToSpawn = beatToSpawn;
|
|
BeatAction.New(instance, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beatToSpawn - 0.3f, delegate { currentTapAnim = TapTroupeTapper.TapAnim.LastTap; shouldSwitchStep = false; }),
|
|
new BeatAction.Action(beatToSpawn, delegate { NPCTap(TapTroupeTapper.TapAnim.LastTap, true, false);}),
|
|
new BeatAction.Action(beatToSpawn + 0.1f, delegate { tapping = false; })
|
|
});
|
|
}
|
|
else if (i + 1.5f >= actualLength)
|
|
{
|
|
soundToPlay = "tapvoice2";
|
|
BeatAction.New(instance, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beatToSpawn - 0.3f, delegate { currentTapAnim = TapTroupeTapper.TapAnim.Tap; shouldSwitchStep = false; }),
|
|
new BeatAction.Action(beatToSpawn, delegate { NPCTap(TapTroupeTapper.TapAnim.Tap, true, false); })
|
|
});
|
|
}
|
|
else if (i + 2.25f >= actualLength)
|
|
{
|
|
soundToPlay = "tapvoice1";
|
|
if (actualLength == 2.25f)
|
|
{
|
|
BeatAction.New(instance, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beatToSpawn - 0.3f, delegate { currentTapAnim = TapTroupeTapper.TapAnim.Tap; shouldSwitchStep = true; }),
|
|
new BeatAction.Action(beatToSpawn, delegate { NPCTap(TapTroupeTapper.TapAnim.Tap); })
|
|
});
|
|
}
|
|
else
|
|
{
|
|
BeatAction.New(instance, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beatToSpawn - 0.3f, delegate { currentTapAnim = TapTroupeTapper.TapAnim.Tap; shouldSwitchStep = false; }),
|
|
new BeatAction.Action(beatToSpawn, delegate { NPCTap(TapTroupeTapper.TapAnim.Tap, true, false); })
|
|
});
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (secondBam) soundToPlay = "bamvoice2";
|
|
if (i + 3f >= actualLength)
|
|
{
|
|
if (actualLength == 3f)
|
|
{
|
|
BeatAction.New(instance, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beatToSpawn - 0.3f, delegate { currentTapAnim = TapTroupeTapper.TapAnim.Tap; shouldSwitchStep = true; }),
|
|
new BeatAction.Action(beatToSpawn, delegate { NPCTap(TapTroupeTapper.TapAnim.Tap); })
|
|
});
|
|
}
|
|
else
|
|
{
|
|
BeatAction.New(instance, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beatToSpawn - 0.3f, delegate { currentTapAnim = TapTroupeTapper.TapAnim.BamTapReady; shouldSwitchStep = true; }),
|
|
new BeatAction.Action(beatToSpawn, delegate { NPCTap(TapTroupeTapper.TapAnim.BamTapReady); })
|
|
});
|
|
}
|
|
}
|
|
else if (i == 0)
|
|
{
|
|
BeatAction.New(instance, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beatToSpawn - 0.3f, delegate { currentTapAnim = TapTroupeTapper.TapAnim.BamReady; shouldSwitchStep = false; }),
|
|
new BeatAction.Action(beatToSpawn, delegate { NPCTap(TapTroupeTapper.TapAnim.BamReady, true, false); })
|
|
});
|
|
}
|
|
else
|
|
{
|
|
|
|
BeatAction.New(instance, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beatToSpawn - 0.3f, delegate { currentTapAnim = TapTroupeTapper.TapAnim.Bam; shouldSwitchStep = true; }),
|
|
new BeatAction.Action(beatToSpawn, delegate { NPCTap(TapTroupeTapper.TapAnim.Bam); }),
|
|
new BeatAction.Action(beatToSpawn + 0.1f, delegate { if (playerTapper.transform.localScale.x != npcTappers[0].transform.localScale.x) playerTapper.dontSwitchNextStep = true; })
|
|
});
|
|
}
|
|
}
|
|
soundsToPlay.Add(new MultiSound.Sound($"tapTroupe/{soundToPlay}", beatToSpawn));
|
|
soundsToPlay.Add(new MultiSound.Sound($"tapTroupe/{otherSoundToPlay}", beatToSpawn));
|
|
shouldDoSecondBam = secondBam;
|
|
secondBam = !secondBam;
|
|
ScheduleInput(beatToSpawn - 1, 1f, InputAction_BasicPress, JustTap, MissTap, Nothing);
|
|
}
|
|
int actualOkayType = okayType;
|
|
if (actualOkayType == (int)OkayType.Random) actualOkayType = UnityEngine.Random.Range(0, 3);
|
|
int randomO = UnityEngine.Random.Range(0, 3);
|
|
string okayVoiceLine = "A";
|
|
string okayOneVoiceLine = "A";
|
|
switch (actualOkayType)
|
|
{
|
|
case (int)OkayType.OkayA:
|
|
okayVoiceLine = "A";
|
|
break;
|
|
case (int)OkayType.OkayB:
|
|
okayVoiceLine = "B";
|
|
break;
|
|
case (int)OkayType.OkayC:
|
|
okayVoiceLine = "C";
|
|
break;
|
|
default:
|
|
okayVoiceLine = "A";
|
|
break;
|
|
}
|
|
switch (randomO)
|
|
{
|
|
case (int)OkayType.OkayA:
|
|
okayOneVoiceLine = "A";
|
|
break;
|
|
case (int)OkayType.OkayB:
|
|
okayOneVoiceLine = "B";
|
|
break;
|
|
case (int)OkayType.OkayC:
|
|
okayOneVoiceLine = "C";
|
|
break;
|
|
default:
|
|
okayOneVoiceLine = "A";
|
|
break;
|
|
}
|
|
BeatAction.New(instance, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beat - 1f, delegate
|
|
{
|
|
if (!stepping)
|
|
{
|
|
NPCStep(false);
|
|
playerTapper.Step(false);
|
|
playerCorner.Bop();
|
|
}
|
|
}),
|
|
new BeatAction.Action(beat, delegate { tapping = true; missedTaps = false; }),
|
|
new BeatAction.Action(finalBeatToSpawn, delegate
|
|
{
|
|
if (missedTaps || animType != (int)OkayAnimType.Popper) return;
|
|
npcCorners[0].PartyPopper(finalBeatToSpawn + popperBeats);
|
|
}),
|
|
new BeatAction.Action(finalBeatToSpawn + 0.5f, delegate
|
|
{
|
|
if (missedTaps || !okay) return;
|
|
playerCorner.Okay();
|
|
foreach (var corner in npcCorners)
|
|
{
|
|
corner.Okay();
|
|
}
|
|
MultiSound.Play(new MultiSound.Sound[]
|
|
{
|
|
new MultiSound.Sound($"tapTroupe/okay{okayOneVoiceLine}1", finalBeatToSpawn + 0.5f),
|
|
new MultiSound.Sound($"tapTroupe/okay{okayVoiceLine}2", finalBeatToSpawn + 1f, 1f, 0.75f),
|
|
}, forcePlay: true);
|
|
}),
|
|
new BeatAction.Action(finalBeatToSpawn + 1f, delegate
|
|
{
|
|
if (!missedTaps && okay && randomVoiceLine && UnityEngine.Random.Range(1, 50) == 1)
|
|
{
|
|
SoundByte.PlayOneShotGame("tapTroupe/woo");
|
|
}
|
|
else if (!missedTaps && okay && randomVoiceLine && UnityEngine.Random.Range(1, 50) == 1)
|
|
{
|
|
SoundByte.PlayOneShotGame("tapTroupe/laughter", -1, 1, 0.4f);
|
|
}
|
|
if (missedTaps || animType != (int)OkayAnimType.OkSign) return;
|
|
playerCorner.OkaySign();
|
|
foreach (var corner in npcCorners)
|
|
{
|
|
corner.OkaySign();
|
|
}
|
|
})
|
|
});
|
|
MultiSound.Play(soundsToPlay.ToArray(), forcePlay: true);
|
|
}
|
|
|
|
public void Bop(double beat, float length, bool shouldBop, bool autoBop)
|
|
{
|
|
goBop = autoBop;
|
|
if (shouldBop)
|
|
{
|
|
for (int i = 0; i < length; i++)
|
|
{
|
|
BeatAction.New(instance, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beat + i, delegate
|
|
{
|
|
BopSingle();
|
|
})
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
public void BopSingle()
|
|
{
|
|
playerTapper.Bop();
|
|
playerCorner.Bop();
|
|
foreach (var tapper in npcTappers)
|
|
{
|
|
tapper.Bop();
|
|
}
|
|
foreach (var corner in npcCorners)
|
|
{
|
|
corner.Bop();
|
|
}
|
|
}
|
|
|
|
public void ToggleMissFace(bool isOn)
|
|
{
|
|
useTutorialMissFace = isOn;
|
|
}
|
|
|
|
public void Spotlights(bool isOn, bool player, bool middleLeft, bool middleRight, bool leftMost)
|
|
{
|
|
if (isOn)
|
|
{
|
|
darkness.SetActive(true);
|
|
spotlightPlayer.SetActive(player);
|
|
spotlightMiddleLeft.SetActive(middleLeft);
|
|
spotlightMiddleRight.SetActive(middleRight);
|
|
spotlightLeftMost.SetActive(leftMost);
|
|
}
|
|
else
|
|
{
|
|
darkness.SetActive(false);
|
|
spotlightPlayer.SetActive(false);
|
|
spotlightMiddleLeft.SetActive(false);
|
|
spotlightMiddleRight.SetActive(false);
|
|
spotlightLeftMost.SetActive(false);
|
|
}
|
|
}
|
|
|
|
public void NPCStep(bool hit = true, bool switchFeet = true)
|
|
{
|
|
foreach (var tapper in npcTappers)
|
|
{
|
|
tapper.Step(hit, switchFeet);
|
|
}
|
|
foreach (var corner in npcCorners)
|
|
{
|
|
corner.Bop();
|
|
}
|
|
}
|
|
|
|
public void NPCTap(TapTroupeTapper.TapAnim animType, bool hit = true, bool switchFeet = true)
|
|
{
|
|
foreach (var tapper in npcTappers)
|
|
{
|
|
tapper.Tap(animType, hit, switchFeet);
|
|
}
|
|
foreach (var corner in npcCorners)
|
|
{
|
|
corner.Bop();
|
|
}
|
|
}
|
|
|
|
void JustStep(PlayerActionEvent caller, float state)
|
|
{
|
|
if (state >= 1f || state <= -1f)
|
|
{
|
|
canSpit = true;
|
|
playerTapper.Step(false);
|
|
playerCorner.Bop();
|
|
SoundByte.PlayOneShotGame("tapTroupe/tink");
|
|
if (stepSound == 1)
|
|
{
|
|
stepSound = 2;
|
|
}
|
|
else
|
|
{
|
|
stepSound = 1;
|
|
}
|
|
foreach (var corner in npcCorners)
|
|
{
|
|
if (useTutorialMissFace)
|
|
{
|
|
corner.SetMissFace(TapTroupeCorner.MissFace.LOL);
|
|
}
|
|
else
|
|
{
|
|
corner.SetMissFace(TapTroupeCorner.MissFace.Sad);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
SuccessStep(caller);
|
|
}
|
|
|
|
void SuccessStep(PlayerActionEvent caller)
|
|
{
|
|
canSpit = true;
|
|
playerTapper.Step();
|
|
|
|
playerCorner.Bop();
|
|
SoundByte.PlayOneShotGame($"tapTroupe/step{stepSound}");
|
|
if (stepSound == 1)
|
|
{
|
|
stepSound = 2;
|
|
}
|
|
else
|
|
{
|
|
stepSound = 1;
|
|
}
|
|
foreach (var corner in npcCorners)
|
|
{
|
|
corner.ResetFace();
|
|
}
|
|
BeatAction.New(instance, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(caller.startBeat + caller.timer + 0.1f, delegate { if (playerTapper.transform.localScale.x != npcTappers[0].transform.localScale.x) playerTapper.dontSwitchNextStep = true; })
|
|
});
|
|
}
|
|
|
|
void MissStep(PlayerActionEvent caller)
|
|
{
|
|
if (canSpit && !useTutorialMissFace) SoundByte.PlayOneShotGame("tapTroupe/spit", -1, 1, 0.5f);
|
|
foreach (var corner in npcCorners)
|
|
{
|
|
if (useTutorialMissFace)
|
|
{
|
|
corner.SetMissFace(TapTroupeCorner.MissFace.LOL);
|
|
}
|
|
else
|
|
{
|
|
corner.SetMissFace(TapTroupeCorner.MissFace.Spit);
|
|
}
|
|
}
|
|
canSpit = false;
|
|
}
|
|
|
|
void JustTap(PlayerActionEvent caller, float state)
|
|
{
|
|
if (state >= 1f || state <= -1f)
|
|
{
|
|
missedTaps = true;
|
|
canSpit = true;
|
|
playerTapper.Tap(currentTapAnim, false, shouldSwitchStep);
|
|
playerCorner.Bop();
|
|
switch (currentTapAnim)
|
|
{
|
|
case TapTroupeTapper.TapAnim.LastTap:
|
|
SoundByte.PlayOneShotGame("tapTroupe/tap3");
|
|
break;
|
|
default:
|
|
SoundByte.PlayOneShotGame("tapTroupe/tink");
|
|
break;
|
|
}
|
|
foreach (var corner in npcCorners)
|
|
{
|
|
if (useTutorialMissFace)
|
|
{
|
|
corner.SetMissFace(TapTroupeCorner.MissFace.LOL);
|
|
}
|
|
else
|
|
{
|
|
corner.SetMissFace(TapTroupeCorner.MissFace.Sad);
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
SuccessTap();
|
|
}
|
|
|
|
void SuccessTap()
|
|
{
|
|
canSpit = true;
|
|
playerTapper.Tap(currentTapAnim, true, shouldSwitchStep);
|
|
playerCorner.Bop();
|
|
switch (currentTapAnim)
|
|
{
|
|
case TapTroupeTapper.TapAnim.LastTap:
|
|
SoundByte.PlayOneShotGame("tapTroupe/tap3");
|
|
break;
|
|
default:
|
|
SoundByte.PlayOneShotGame("tapTroupe/player3");
|
|
break;
|
|
}
|
|
foreach (var corner in npcCorners)
|
|
{
|
|
corner.ResetFace();
|
|
}
|
|
}
|
|
|
|
void MissTap(PlayerActionEvent caller)
|
|
{
|
|
missedTaps = true;
|
|
if (canSpit && !useTutorialMissFace) SoundByte.PlayOneShotGame("tapTroupe/spit", -1, 1, 0.5f);
|
|
foreach (var corner in npcCorners)
|
|
{
|
|
if (useTutorialMissFace)
|
|
{
|
|
corner.SetMissFace(TapTroupeCorner.MissFace.LOL);
|
|
}
|
|
else
|
|
{
|
|
corner.SetMissFace(TapTroupeCorner.MissFace.Spit);
|
|
}
|
|
}
|
|
canSpit = false;
|
|
}
|
|
|
|
void Nothing(PlayerActionEvent caller) { }
|
|
}
|
|
}
|