714 lines
29 KiB
C#
714 lines
29 KiB
C#
using HeavenStudio.Util;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using Jukebox;
|
|
|
|
namespace HeavenStudio.Games.Loaders
|
|
{
|
|
using static Minigames;
|
|
public static class RvlMonkeyWatchLoader
|
|
{
|
|
public static Minigame AddGame(EventCaller eventCaller)
|
|
{
|
|
return new Minigame("monkeyWatch", "Monkey Watch", "f0338d", false, false, new List<GameAction>()
|
|
{
|
|
new GameAction("appear", "Monkeys Appear")
|
|
{
|
|
function = delegate
|
|
{
|
|
var e = eventCaller.currentEntity;
|
|
MonkeyWatch.instance.MonkeysAppear(e.beat, e.length, e["value"], e.beat);
|
|
},
|
|
defaultLength = 2f,
|
|
resizable = true,
|
|
parameters = new List<Param>()
|
|
{
|
|
new Param("value", new EntityTypes.Integer(1, 30, 4), "Repeat Amount")
|
|
}
|
|
},
|
|
new GameAction("clap", "Clapping")
|
|
{
|
|
preFunction = delegate
|
|
{
|
|
MonkeyWatch.PreStartClapping(eventCaller.currentEntity.beat);
|
|
},
|
|
preFunctionLength = 4f,
|
|
defaultLength = 2f,
|
|
parameters = new List<Param>()
|
|
{
|
|
new Param("min", new EntityTypes.Integer(0, 59, 0), "Starting Second", "A second is equivalent to one monkey.")
|
|
}
|
|
},
|
|
new GameAction("off", "Pink Monkeys")
|
|
{
|
|
preFunction = delegate
|
|
{
|
|
var e = eventCaller.currentEntity;
|
|
MonkeyWatch.PinkMonkeySound(e.beat, e.length, e["muteC"], e["muteE"]);
|
|
},
|
|
defaultLength = 2f,
|
|
parameters = new List<Param>()
|
|
{
|
|
new Param("muteC", false, "Mute Ooki"),
|
|
new Param("muteE", false, "Mute Eeks")
|
|
}
|
|
},
|
|
new GameAction("offStretch", "Pink Monkeys (Stretchable)")
|
|
{
|
|
preFunction = delegate
|
|
{
|
|
var e = eventCaller.currentEntity;
|
|
MonkeyWatch.PinkMonkeySound(e.beat, e.length, e["muteC"], e["muteE"]);
|
|
},
|
|
defaultLength = 2f,
|
|
resizable = true,
|
|
parameters = new List<Param>()
|
|
{
|
|
new Param("muteC", false, "Mute Ooki"),
|
|
new Param("muteE", false, "Mute Eeks")
|
|
}
|
|
},
|
|
new GameAction("offInterval", "Custom Pink Monkey Interval")
|
|
{
|
|
preFunction = delegate
|
|
{
|
|
var e = eventCaller.currentEntity;
|
|
MonkeyWatch.PinkMonkeySoundCustom(e.beat, e.length, e["muteC"], e["muteE"]);
|
|
},
|
|
defaultLength = 2f,
|
|
resizable = true,
|
|
parameters = new List<Param>()
|
|
{
|
|
new Param("muteC", false, "Mute Ooki"),
|
|
new Param("muteE", false, "Mute Eeks")
|
|
}
|
|
},
|
|
new GameAction("offCustom", "Custom Pink Monkey")
|
|
{
|
|
defaultLength = 0.5f
|
|
},
|
|
new GameAction("zoomOut", "Zoom Out")
|
|
{
|
|
function = delegate
|
|
{
|
|
var e = eventCaller.currentEntity;
|
|
MonkeyWatch.instance.ZoomOut(e.beat, e["timeMode"], e["hour"], e["minute"], e["instant"]);
|
|
},
|
|
defaultLength = 2f,
|
|
parameters = new List<Param>()
|
|
{
|
|
new Param("instant", false, "Instant"),
|
|
new Param("timeMode", MonkeyWatch.TimeMode.RealTime, "Time Mode", "Set the clock to system time or a specific time."),
|
|
new Param("hour", new EntityTypes.Integer(0, 12, 3), "Hour"),
|
|
new Param("minute", new EntityTypes.Integer(0, 59, 0), "Minute")
|
|
}
|
|
},
|
|
new GameAction("zoomIn", "Zoom In")
|
|
{
|
|
function = delegate
|
|
{
|
|
var e = eventCaller.currentEntity;
|
|
MonkeyWatch.instance.ZoomIn(e.beat, e["timeMode"], e["hour"], e["minute"], e["instant"]);
|
|
},
|
|
defaultLength = 2f,
|
|
parameters = new List<Param>()
|
|
{
|
|
new Param("instant", false, "Instant"),
|
|
new Param("timeMode", MonkeyWatch.TimeMode.RealTime, "Time Mode", "Set the clock to system time or a specific time."),
|
|
new Param("hour", new EntityTypes.Integer(0, 12, 3), "Hour"),
|
|
new Param("minute", new EntityTypes.Integer(0, 59, 0), "Minute")
|
|
}
|
|
},
|
|
new GameAction("balloon", "Balloon Movement")
|
|
{
|
|
resizable = true,
|
|
defaultLength = 4f,
|
|
parameters = new List<Param>()
|
|
{
|
|
new Param("angleStart", new EntityTypes.Float(-360, 360, 0), "Start Angle"),
|
|
new Param("angleEnd", new EntityTypes.Float(-360, 360, 0), "End Angle"),
|
|
new Param("yStart", new EntityTypes.Float(-200, 200, 0), "Y Start"),
|
|
new Param("yEnd", new EntityTypes.Float(-200, 200, 0), "Y End"),
|
|
new Param("xStart", new EntityTypes.Float(-200, 200, 0), "X Start"),
|
|
new Param("xEnd", new EntityTypes.Float(-200, 200, 0), "X End"),
|
|
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease")
|
|
}
|
|
}
|
|
},
|
|
new List<string>() {"rvl", "keep"},
|
|
chronologicalSortKey: 9);
|
|
}
|
|
}
|
|
}
|
|
|
|
namespace HeavenStudio.Games
|
|
{
|
|
using Scripts_MonkeyWatch;
|
|
|
|
public class MonkeyWatch : Minigame
|
|
{
|
|
public enum TimeMode
|
|
{
|
|
RealTime,
|
|
SetTime
|
|
}
|
|
|
|
private const float degreePerMonkey = 6f;
|
|
|
|
public static MonkeyWatch instance;
|
|
|
|
[Header("Components")]
|
|
[SerializeField] private Transform cameraAnchor;
|
|
[SerializeField] private Transform cameraTransform;
|
|
[SerializeField] private Transform cameraMoveable;
|
|
public MonkeyClockArrow monkeyClockArrow;
|
|
[SerializeField] private WatchMonkeyHandler monkeyHandler;
|
|
[SerializeField] private WatchBackgroundHandler backgroundHandler;
|
|
[SerializeField] private BalloonHandler balloonHandler;
|
|
public Animator middleMonkey;
|
|
|
|
[Header("Properties")]
|
|
[SerializeField] private float fullZoomOut = 40f;
|
|
[SerializeField] private Util.EasingFunction.Ease zoomOutEase;
|
|
[SerializeField] private float zoomOutBeatLength = 2f;
|
|
[SerializeField] private float zoomInBeatLength = 2f;
|
|
[SerializeField] private Util.EasingFunction.Ease zoomInEase;
|
|
private float lastAngle = 0f;
|
|
//private int cameraIndex = 0; Unused value - Marc
|
|
private float cameraWantAngle, cameraAngleDelay;
|
|
private float delayRate = 0.5f, targetDelayRate;
|
|
|
|
private void Awake()
|
|
{
|
|
instance = this;
|
|
funcOut = Util.EasingFunction.GetEasingFunction(zoomOutEase);
|
|
funcIn = Util.EasingFunction.GetEasingFunction(zoomInEase);
|
|
pinkMonkeys = EventCaller.GetAllInGameManagerList("monkeyWatch", new string[] { "off", "offStretch" });
|
|
pinkMonkeysCustom = EventCaller.GetAllInGameManagerList("monkeyWatch", new string[] { "offInterval" });
|
|
}
|
|
|
|
private void Start()
|
|
{
|
|
CameraUpdate();
|
|
}
|
|
|
|
//private double lastReportedBeat = 0; Unused value - Marc
|
|
|
|
private void Update()
|
|
{
|
|
CameraUpdate();
|
|
}
|
|
|
|
public override void OnBeatPulse(double beat)
|
|
{
|
|
middleMonkey.DoScaledAnimationAsync("MiddleMonkeyBop", 0.4f);
|
|
}
|
|
|
|
public void PlayerMonkeyClap(bool big, bool barely)
|
|
{
|
|
monkeyClockArrow.PlayerClap(big, barely, false);
|
|
}
|
|
|
|
public void ZoomOut(double beat, int timeMode, int hours, int minutes, bool instant)
|
|
{
|
|
zoomOutStartBeat = beat - (instant ? zoomOutBeatLength : 0);
|
|
zoomIn = false;
|
|
backgroundHandler.SetFade(beat, instant ? 0 : 0.25f, true, (TimeMode)timeMode, hours, minutes);
|
|
CameraUpdate();
|
|
}
|
|
public void ZoomIn(double beat, int timeMode, int hours, int minutes, bool instant)
|
|
{
|
|
zoomOutStartBeat = beat - (instant ? zoomInBeatLength : 0);
|
|
zoomIn = true;
|
|
backgroundHandler.SetFade(beat, instant ? 0 : 0.25f, false, (TimeMode)timeMode, hours, minutes);
|
|
CameraUpdate();
|
|
}
|
|
|
|
public void PersistZoomOut(double beat)
|
|
{
|
|
var allZooms = EventCaller.GetAllInGameManagerList("monkeyWatch", new string[] { "zoomOut" }).FindAll(x => x.beat < beat && x.beat + x.length > beat);
|
|
foreach (var zoom in allZooms)
|
|
{
|
|
ZoomOut(zoom.beat, zoom["timeMode"], zoom["hour"], zoom["minute"], zoom["instant"]);
|
|
}
|
|
var allZoomsIn = EventCaller.GetAllInGameManagerList("monkeyWatch", new string[] { "zoomIn" }).FindAll(x => x.beat < beat && x.beat + x.length > beat);
|
|
foreach (var zoom in allZoomsIn)
|
|
{
|
|
ZoomIn(zoom.beat, zoom["timeMode"], zoom["hour"], zoom["minute"], zoom["instant"]);
|
|
}
|
|
}
|
|
|
|
private double persistBeat = 0;
|
|
private double theNextGameSwitchBeat = double.MaxValue;
|
|
private double clappingBeat = 0;
|
|
|
|
public override void OnGameSwitch(double beat)
|
|
{
|
|
balloonHandler.Init(beat);
|
|
persistBeat = beat;
|
|
GetCameraMovements(beat, false);
|
|
monkeyClockArrow.MoveToAngle(lastAngle);
|
|
monkeyHandler.Init((int)(lastAngle / degreePerMonkey));
|
|
if (wantClap >= beat && IsClapBeat(wantClap))
|
|
{
|
|
StartClapping(wantClap);
|
|
}
|
|
PersistAppear(beat);
|
|
PersistZoomOut(beat);
|
|
|
|
bool IsClapBeat(double clapBeat)
|
|
{
|
|
return EventCaller.GetAllInGameManagerList("monkeyWatch", new string[] { "clap" }).Find(x => x.beat == clapBeat) != null;
|
|
}
|
|
}
|
|
|
|
public override void OnPlay(double beat)
|
|
{
|
|
balloonHandler.Init(beat);
|
|
persistBeat = beat;
|
|
GetCameraMovements(beat, true);
|
|
monkeyClockArrow.MoveToAngle(lastAngle);
|
|
monkeyHandler.Init((int)(lastAngle / degreePerMonkey));
|
|
PersistAppear(beat);
|
|
PersistZoomOut(beat);
|
|
}
|
|
|
|
private void PersistAppear(double beat)
|
|
{
|
|
var allEvents = EventCaller.GetAllInGameManagerList("monkeyWatch", new string[] { "appear" }).FindAll(x => x.beat + x["value"] > beat && x.beat < beat);
|
|
|
|
foreach (var e in allEvents)
|
|
{
|
|
MonkeysAppear(e.beat, e.length, e["value"], beat);
|
|
}
|
|
}
|
|
|
|
public void MonkeysAppear(double beat, float length, int repeatAmount, double gameSwitchBeat)
|
|
{
|
|
List<BeatAction.Action> actions = new();
|
|
|
|
double lastBeat = clappingBeat;
|
|
|
|
int index = 0;
|
|
while (index < repeatAmount)
|
|
{
|
|
|
|
if (IsPinkMonkeyAtBeat(lastBeat, out float pinkLength))
|
|
{
|
|
for (int i = 0; i < pinkLength; i++)
|
|
{
|
|
if (index >= repeatAmount) break;
|
|
bool beforeGameSwitch = beat + (index * length) < gameSwitchBeat;
|
|
double realLastBeat = lastBeat;
|
|
actions.Add(new BeatAction.Action(beat + (index * length), delegate
|
|
{
|
|
monkeyHandler.SpawnMonkey(realLastBeat, true, beforeGameSwitch);
|
|
}));
|
|
index++;
|
|
lastBeat += 1;
|
|
}
|
|
}
|
|
else if (IsCustomPinkMonkeyAtBeat(lastBeat, out float pinkCustomLength))
|
|
{
|
|
var relevantPinks = FindCustomOffbeatMonkeysBetweenBeat(lastBeat, lastBeat + pinkCustomLength);
|
|
relevantPinks.Sort((x, y) => x.beat.CompareTo(y.beat));
|
|
|
|
for (int i = 0; i < relevantPinks.Count; i++)
|
|
{
|
|
if (index >= repeatAmount) break;
|
|
int jindex = i;
|
|
bool beforeGameSwitch = beat + (index * length) < gameSwitchBeat;
|
|
actions.Add(new BeatAction.Action(beat + (index * length), delegate
|
|
{
|
|
monkeyHandler.SpawnMonkey(relevantPinks[jindex].beat, true, beforeGameSwitch);
|
|
}));
|
|
index++;
|
|
}
|
|
lastBeat += pinkCustomLength;
|
|
}
|
|
else
|
|
{
|
|
double realLastBeat = lastBeat;
|
|
bool beforeGameSwitch = beat + (index * length) < gameSwitchBeat;
|
|
actions.Add(new BeatAction.Action(beat + (index * length), delegate
|
|
{
|
|
monkeyHandler.SpawnMonkey(realLastBeat, false, beforeGameSwitch);
|
|
}));
|
|
index++;
|
|
lastBeat += 2;
|
|
}
|
|
}
|
|
|
|
actions.Sort((x, y) => x.beat.CompareTo(y.beat));
|
|
BeatAction.New(instance, actions);
|
|
}
|
|
|
|
#region clapping
|
|
|
|
private bool clapRecursing = false;
|
|
private List<RiqEntity> pinkMonkeys = new();
|
|
private List<RiqEntity> pinkMonkeysCustom = new();
|
|
|
|
private bool IsPinkMonkeyAtBeat(double beat, out float length)
|
|
{
|
|
length = 2;
|
|
var e = pinkMonkeys.Find(x => x.beat == beat);
|
|
bool isNotNull = e != null;
|
|
if (isNotNull) length = e.length;
|
|
return isNotNull;
|
|
}
|
|
|
|
private bool IsCustomPinkMonkeyAtBeat(double beat, out float length)
|
|
{
|
|
length = 2;
|
|
var e = pinkMonkeysCustom.Find(x => x.beat == beat);
|
|
bool isNotNull = e != null;
|
|
if (isNotNull) length = e.length;
|
|
return isNotNull;
|
|
}
|
|
|
|
private static double wantClap = double.MinValue;
|
|
|
|
public static void PreStartClapping(double beat)
|
|
{
|
|
if (GameManager.instance.currentGame == "monkeyWatch")
|
|
{
|
|
instance.StartClapping(beat);
|
|
}
|
|
wantClap = beat;
|
|
}
|
|
|
|
private void StartClapping(double beat)
|
|
{
|
|
if (clapRecursing) return;
|
|
clapRecursing = true;
|
|
|
|
ClapRecursing(beat);
|
|
}
|
|
|
|
private void ClapRecursing(double beat)
|
|
{
|
|
if (beat >= theNextGameSwitchBeat) return;
|
|
if (IsPinkMonkeyAtBeat(beat, out float length1))
|
|
{
|
|
PinkClap(length1);
|
|
}
|
|
else if (IsCustomPinkMonkeyAtBeat(beat, out float length2))
|
|
{
|
|
PinkClapCustom(length2);
|
|
}
|
|
else
|
|
{
|
|
NormalClap();
|
|
}
|
|
|
|
void NormalClap()
|
|
{
|
|
BeatAction.New(instance, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beat - 4, delegate
|
|
{
|
|
monkeyHandler.SpawnMonkey(beat, false, beat - 4 < persistBeat);
|
|
ClapRecursing(beat + 2);
|
|
cameraWantAngle += degreePerMonkey;
|
|
}),
|
|
new BeatAction.Action(beat - 1, delegate
|
|
{
|
|
monkeyHandler.GetMonkeyAtBeat(beat).Prepare(beat, beat + 1);
|
|
}),
|
|
});
|
|
}
|
|
|
|
void PinkClap(float length)
|
|
{
|
|
List<BeatAction.Action> actions = new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beat - 4, delegate
|
|
{
|
|
ClapRecursing(beat + length);
|
|
})
|
|
};
|
|
|
|
for (int i = 0; i < length; i++)
|
|
{
|
|
int index = i;
|
|
actions.AddRange(new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beat + i - 4, delegate
|
|
{
|
|
monkeyHandler.SpawnMonkey(beat + index, true, beat + index - 4 < persistBeat);
|
|
cameraWantAngle += degreePerMonkey;
|
|
}),
|
|
new BeatAction.Action(beat + i - 1, delegate
|
|
{
|
|
monkeyHandler.GetMonkeyAtBeat(beat + index).Prepare(beat + index, beat + index + 0.5);
|
|
}),
|
|
});
|
|
}
|
|
actions.Sort((x, y) => x.beat.CompareTo(y.beat));
|
|
BeatAction.New(instance, actions);
|
|
}
|
|
|
|
void PinkClapCustom(float length)
|
|
{
|
|
List<BeatAction.Action> actions = new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beat - 4, delegate
|
|
{
|
|
ClapRecursing(beat + length);
|
|
})
|
|
};
|
|
|
|
var relevantEvents = FindCustomOffbeatMonkeysBetweenBeat(beat, beat + length);
|
|
relevantEvents.Sort((x, y) => x.beat.CompareTo(y.beat));
|
|
|
|
for (int i = 0; i < relevantEvents.Count; i++)
|
|
{
|
|
var e = relevantEvents[i];
|
|
actions.AddRange(new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(e.beat - 4, delegate
|
|
{
|
|
monkeyHandler.SpawnMonkey(e.beat, true, e.beat - 4 < persistBeat);
|
|
cameraWantAngle += degreePerMonkey;
|
|
}),
|
|
new BeatAction.Action(e.beat - 1.5, delegate
|
|
{
|
|
monkeyHandler.GetMonkeyAtBeat(e.beat).Prepare(e.beat - 0.5, e.beat);
|
|
}),
|
|
});
|
|
}
|
|
actions.Sort((x, y) => x.beat.CompareTo(y.beat));
|
|
BeatAction.New(instance, actions);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
#region Camera
|
|
private void GetCameraMovements(double beat, bool onPlay)
|
|
{
|
|
double lastGameSwitchBeat = beat;
|
|
if (onPlay)
|
|
{
|
|
var allEndsBeforeBeat = EventCaller.GetAllInGameManagerList("gameManager", new string[] { "switchGame" }).FindAll(x => x.beat <= beat);
|
|
if (allEndsBeforeBeat.Count > 0)
|
|
{
|
|
allEndsBeforeBeat.Sort((x, y) => x.beat.CompareTo(y.beat));
|
|
lastGameSwitchBeat = allEndsBeforeBeat[^1].beat;
|
|
}
|
|
else
|
|
{
|
|
lastGameSwitchBeat = 0f;
|
|
}
|
|
}
|
|
|
|
double nextGameSwitchBeat = double.MaxValue;
|
|
|
|
var allEnds = EventCaller.GetAllInGameManagerList("gameManager", new string[] { "switchGame", "end" }).FindAll(x => x.beat > lastGameSwitchBeat);
|
|
if (allEnds.Count > 0)
|
|
{
|
|
allEnds.Sort((x, y) => x.beat.CompareTo(y.beat));
|
|
nextGameSwitchBeat = allEnds[0].beat;
|
|
}
|
|
|
|
theNextGameSwitchBeat = nextGameSwitchBeat;
|
|
|
|
double startClappingBeat = 0;
|
|
float startAngle = 0;
|
|
bool overrideStartBeat = true;
|
|
|
|
var clappingEvents = EventCaller.GetAllInGameManagerList("monkeyWatch", new string[] { "clap" }).FindAll(x => x.beat >= lastGameSwitchBeat && x.beat < nextGameSwitchBeat);
|
|
if (clappingEvents.Count > 0)
|
|
{
|
|
clappingEvents.Sort((x, y) => x.beat.CompareTo(y.beat));
|
|
startClappingBeat = clappingEvents[0].beat;
|
|
startAngle = clappingEvents[0]["min"] * degreePerMonkey;
|
|
cameraWantAngle = startAngle;
|
|
cameraAngleDelay = startAngle;
|
|
overrideStartBeat = false;
|
|
}
|
|
lastAngle = startAngle;
|
|
clappingBeat = startClappingBeat;
|
|
|
|
var pinkClappingEvents = EventCaller.GetAllInGameManagerList("monkeyWatch", new string[] { "off", "offStretch", "offInterval" }).FindAll(x => x.beat >= lastGameSwitchBeat && x.beat < nextGameSwitchBeat);
|
|
if (pinkClappingEvents.Count > 0)
|
|
{
|
|
pinkClappingEvents.Sort((x, y) => x.beat.CompareTo(y.beat));
|
|
if (overrideStartBeat) startClappingBeat = pinkClappingEvents[0].beat;
|
|
clappingBeat = startClappingBeat;
|
|
|
|
var relevantPinkClappingEvents = pinkClappingEvents.FindAll(x => (x.beat - startClappingBeat) % 2 == 0);
|
|
relevantPinkClappingEvents.Sort((x, y) => x.beat.CompareTo(y.beat));
|
|
|
|
double lastClappingBeat = startClappingBeat;
|
|
float lastAngleToCheck = startAngle;
|
|
|
|
for (int i = 0; i < relevantPinkClappingEvents.Count; i++)
|
|
{
|
|
var e = relevantPinkClappingEvents[i];
|
|
if (e.beat < lastClappingBeat) continue;
|
|
|
|
float angleToAdd;
|
|
if (e.datamodel == "monkeyWatch/offInterval")
|
|
{
|
|
angleToAdd = FindCustomOffbeatMonkeysBetweenBeat(e.beat, e.beat + e.length).Count * degreePerMonkey;
|
|
}
|
|
else
|
|
{
|
|
angleToAdd = Mathf.Ceil(e.length) * degreePerMonkey;
|
|
}
|
|
|
|
if (e.beat - lastClappingBeat > 0)
|
|
{
|
|
lastAngleToCheck += (float)((e.beat - lastClappingBeat) / 2) * degreePerMonkey;
|
|
}
|
|
|
|
lastAngleToCheck += angleToAdd;
|
|
lastClappingBeat = e.beat + e.length;
|
|
}
|
|
startClappingBeat = lastClappingBeat;
|
|
startAngle = lastAngleToCheck;
|
|
}
|
|
}
|
|
|
|
private void UpdateCamera()
|
|
{
|
|
// lastAngle = cameraMovements[cameraIndex].degreeTo;
|
|
// cameraIndex++;
|
|
// if (cameraIndex + 1 < cameraMovements.Count && conductor.songPositionInBeats >= cameraMovements[cameraIndex].beat + cameraMovements[cameraIndex].length)
|
|
// {
|
|
// UpdateCamera();
|
|
// }
|
|
}
|
|
|
|
private double zoomOutStartBeat = -2;
|
|
private bool zoomIn = true;
|
|
private Util.EasingFunction.Function funcOut;
|
|
private Util.EasingFunction.Function funcIn;
|
|
|
|
private void CameraUpdate()
|
|
{
|
|
if (conductor.isPlaying && !conductor.isPaused)
|
|
{
|
|
float degreesBehind = cameraWantAngle - 2 * degreePerMonkey;
|
|
float degreesBehindFast = cameraWantAngle - 3f * degreePerMonkey;
|
|
targetDelayRate = Mathf.Max((cameraAngleDelay - degreesBehindFast) / (degreesBehindFast - cameraWantAngle), 0) + 0.5f;
|
|
delayRate = Mathf.Lerp(delayRate, targetDelayRate, Time.deltaTime * (1f / conductor.pitchedSecPerBeat) * 0.5f);
|
|
if (cameraAngleDelay < degreesBehind)
|
|
{
|
|
cameraAngleDelay += degreePerMonkey * Time.deltaTime * (1f / conductor.pitchedSecPerBeat) * delayRate;
|
|
cameraAngleDelay = Mathf.Min(cameraAngleDelay, cameraWantAngle);
|
|
}
|
|
cameraAnchor.localEulerAngles = new Vector3(0, 0, cameraAngleDelay);
|
|
}
|
|
|
|
float normalizedZoomBeat = conductor.GetPositionFromBeat(zoomOutStartBeat, zoomIn ? zoomInBeatLength : zoomOutBeatLength);
|
|
float newX = 0f;
|
|
float newY = 0f;
|
|
float newZ = 0f;
|
|
if (zoomIn)
|
|
{
|
|
newX = funcIn(0, cameraTransform.position.x, Mathf.Clamp01(normalizedZoomBeat));
|
|
newY = funcIn(0, cameraTransform.position.y, Mathf.Clamp01(normalizedZoomBeat));
|
|
newZ = funcIn(fullZoomOut, 0, Mathf.Clamp01(normalizedZoomBeat));
|
|
}
|
|
else
|
|
{
|
|
newX = funcOut(cameraTransform.position.x, 0, Mathf.Clamp01(normalizedZoomBeat));
|
|
newY = funcOut(cameraTransform.position.y, 0, Mathf.Clamp01(normalizedZoomBeat));
|
|
newZ = funcOut(0, fullZoomOut, Mathf.Clamp01(normalizedZoomBeat));
|
|
}
|
|
|
|
if (zoomIn && normalizedZoomBeat > 1f)
|
|
{
|
|
cameraMoveable.position = new Vector3(cameraTransform.position.x, cameraTransform.position.y * -1);
|
|
}
|
|
else
|
|
{
|
|
cameraMoveable.position = new Vector3(newX, -newY, newZ);
|
|
}
|
|
}
|
|
#endregion
|
|
|
|
public static List<RiqEntity> FindCustomOffbeatMonkeysBetweenBeat(double beat, double endBeat)
|
|
{
|
|
return EventCaller.GetAllInGameManagerList("monkeyWatch", new string[] { "offCustom" }).FindAll(x => x.beat >= beat && x.beat < endBeat);
|
|
}
|
|
|
|
#region pink monkey sounds
|
|
|
|
public static void PinkMonkeySound(double beat, float length, bool muteOoki, bool muteEek)
|
|
{
|
|
List<MultiSound.Sound> soundsToPlay = new();
|
|
if (!muteOoki)
|
|
{
|
|
soundsToPlay.AddRange(new List<MultiSound.Sound>()
|
|
{
|
|
new MultiSound.Sound("monkeyWatch/voiceUki1", beat - 2),
|
|
new MultiSound.Sound("monkeyWatch/voiceUki1Echo1", beat - 1.75),
|
|
new MultiSound.Sound("monkeyWatch/voiceUki2", beat - 1),
|
|
new MultiSound.Sound("monkeyWatch/voiceUki2Echo1", beat - 0.75),
|
|
new MultiSound.Sound("monkeyWatch/voiceUki3", beat),
|
|
new MultiSound.Sound("monkeyWatch/voiceUki3Echo1", beat + 0.25),
|
|
});
|
|
}
|
|
|
|
if (!muteEek)
|
|
{
|
|
for (int i = 0; i < length; i++)
|
|
{
|
|
int randomKi = UnityEngine.Random.Range(1, 3);
|
|
soundsToPlay.AddRange(new List<MultiSound.Sound>()
|
|
{
|
|
new MultiSound.Sound($"monkeyWatch/voiceKi{randomKi}", beat + i + 0.5),
|
|
new MultiSound.Sound($"monkeyWatch/voiceKi{randomKi}Echo{UnityEngine.Random.Range(1, 3)}", beat + i + 0.75),
|
|
});
|
|
}
|
|
}
|
|
|
|
if (soundsToPlay.Count > 0) MultiSound.Play(soundsToPlay.ToArray(), forcePlay: true);
|
|
}
|
|
|
|
public static void PinkMonkeySoundCustom(double beat, float length, bool muteOoki, bool muteEek)
|
|
{
|
|
List<MultiSound.Sound> soundsToPlay = new();
|
|
var allCustoms = FindCustomOffbeatMonkeysBetweenBeat(beat, beat + length);
|
|
if (!muteOoki)
|
|
{
|
|
soundsToPlay.AddRange(new List<MultiSound.Sound>()
|
|
{
|
|
new MultiSound.Sound("monkeyWatch/voiceUki1", beat - 2),
|
|
new MultiSound.Sound("monkeyWatch/voiceUki1Echo1", beat - 1.75),
|
|
new MultiSound.Sound("monkeyWatch/voiceUki2", beat - 1),
|
|
new MultiSound.Sound("monkeyWatch/voiceUki2Echo1", beat - 0.75),
|
|
});
|
|
if (allCustoms.Find(x => x.beat == beat) == null)
|
|
{
|
|
soundsToPlay.AddRange(new List<MultiSound.Sound>()
|
|
{
|
|
new MultiSound.Sound("monkeyWatch/voiceUki3", beat),
|
|
new MultiSound.Sound("monkeyWatch/voiceUki3Echo1", beat + 0.25),
|
|
});
|
|
}
|
|
}
|
|
|
|
if (!muteEek)
|
|
{
|
|
foreach (var custom in allCustoms)
|
|
{
|
|
int randomKi = UnityEngine.Random.Range(1, 3);
|
|
soundsToPlay.AddRange(new List<MultiSound.Sound>()
|
|
{
|
|
new MultiSound.Sound($"monkeyWatch/voiceKi{randomKi}", custom.beat),
|
|
new MultiSound.Sound($"monkeyWatch/voiceKi{randomKi}Echo{UnityEngine.Random.Range(1, 3)}", custom.beat + 0.25),
|
|
});
|
|
}
|
|
}
|
|
|
|
if (soundsToPlay.Count > 0) MultiSound.Play(soundsToPlay.ToArray(), forcePlay: true);
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
} |