mirrors/HeavenStudio
1
0
Fork 0
Code Issues Pull requests Packages Projects Releases Wiki Activity

Background Color Change Parity (#530)

Browse source 
* coin toss to see saw

* all done

* more stuffs
This commit is contained in:
Rapandrasmus 2023-08-12 05:30:03 +02:00 committed by GitHub
parent cd94ee3761
commit 74359d3e1c
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
13 changed files with 655 additions and 318 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
Assets/Scripts/Games/BuiltToScaleDS/BuiltToScaleDS.cs
View file

@ -203,6 +203,27 @@ namespace HeavenStudio.Games
UpdateColors(); UpdateColors();
} }
private void PersistColors(double beat)
{
var allEventsBeforeBeat = EventCaller.GetAllInGameManagerList("builtToScaleDS", new string[] { "color" }).FindAll(x => x.beat < beat);
if (allEventsBeforeBeat.Count > 0)
{
allEventsBeforeBeat.Sort((x, y) => x.beat.CompareTo(y.beat));
var lastEvent = allEventsBeforeBeat[^1];
UpdateMappingColors(lastEvent["object"], lastEvent["shooter"], lastEvent["bg"]);
}
}
public override void OnGameSwitch(double beat)
{
PersistColors(beat);
}
public override void OnPlay(double beat)
{
PersistColors(beat);
}
private void UpdateColors() private void UpdateColors()
{ {
objectMaterial.SetColor("_Color", currentObjectColor); objectMaterial.SetColor("_Color", currentObjectColor);

144
Assets/Scripts/Games/CoinToss/CoinToss.cs
View file

@ -1,5 +1,3 @@
using DG.Tweening;
using NaughtyBezierCurves;
using HeavenStudio.Util; using HeavenStudio.Util;
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
@ -24,53 +22,33 @@ namespace HeavenStudio.Games.Loaders
new Param("toggle", false, "Audience Reaction", "Enable Audience Reaction"), new Param("toggle", false, "Audience Reaction", "Enable Audience Reaction"),
} }
}, },
new GameAction("set background color", "Set Background Color") new GameAction("fade background color", "Background Color")
{ {
function = delegate { var e = eventCaller.currentEntity; CoinToss.instance.ChangeBackgroundColor(e["colorA"], 0f); CoinToss.instance.ChangeBackgroundColor(e["colorB"], 0f, true); }, function = delegate { var e = eventCaller.currentEntity;
defaultLength = 0.5f, CoinToss.instance.BackgroundColor(e.beat, e.length, e["colorStart"], e["colorEnd"], e["colorStartF"], e["colorEndF"], e["ease"]); },
parameters = new List<Param>()
{
new Param("colorA", CoinToss.defaultBgColor, "Background Color", "The background color to change to"),
new Param("colorB", CoinToss.defaultFgColor, "Foreground Color", "The foreground color to change to")
}
},
new GameAction("fade background color", "Fade Background Color")
{
function = delegate { var e = eventCaller.currentEntity; CoinToss.instance.FadeBackgroundColor(e["colorA"], e["colorB"], e.length); CoinToss.instance.FadeBackgroundColor(e["colorC"], e["colorD"], e.length, true); },
resizable = true, resizable = true,
defaultLength = 4f,
parameters = new List<Param>() parameters = new List<Param>()
{ {
new Param("colorA", Color.white, "BG Start Color", "The starting color in the fade"), new Param("colorStart", CoinToss.defaultBgColor, "BG Start Color", "The starting color in the fade"),
new Param("colorB", CoinToss.defaultBgColor, "BG End Color", "The ending color in the fade"), new Param("colorEnd", CoinToss.defaultBgColor, "BG End Color", "The ending color in the fade"),
new Param("colorC", Color.white, "FG Start Color", "The starting color in the fade"), new Param("colorStartF", CoinToss.defaultBgColor, "FG Start Color", "The starting color in the fade"),
new Param("colorD", CoinToss.defaultFgColor, "FG End Color", "The ending color in the fade") new Param("colorEndF", CoinToss.defaultBgColor, "FG End Color", "The ending color in the fade"),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease")
} }
}, },
//left in for backwards-compatibility, but cannot be placed //left in for backwards-compatibility, but cannot be placed
new GameAction("set foreground color", "") new GameAction("set background color", "Set Background Color")
{ {
function = delegate { var e = eventCaller.currentEntity; CoinToss.instance.ChangeBackgroundColor(e["colorA"], 0f, true); }, function = delegate { var e = eventCaller.currentEntity; CoinToss.instance.BackgroundColor(e.beat, e.length, e["colorA"], e["colorA"], e["colorB"], e["colorB"], (int)Util.EasingFunction.Ease.Instant); },
defaultLength = 0.5f, defaultLength = 0.5f,
parameters = new List<Param>
{
new Param("colorA", CoinToss.defaultFgColor, "Foreground Color", "The foreground color to change to")
},
hidden = true
},
new GameAction("fade foreground color", "")
{
function = delegate { var e = eventCaller.currentEntity; CoinToss.instance.FadeBackgroundColor(e["colorA"], e["colorB"], e.length, true); },
resizable = true,
parameters = new List<Param>() parameters = new List<Param>()
{ {
new Param("colorA", Color.white, "Start Color", "The starting color in the fade"), new Param("colorA", CoinToss.defaultBgColor, "Background Color", "The background color to change to"),
new Param("colorB", CoinToss.defaultFgColor, "End Color", "The ending color in the fade") new Param("colorB", CoinToss.defaultFgColor, "Foreground Color", "The foreground color to change to")
}, },
hidden = true hidden = true
}, },
}, },
new List<string>() {"ntr", "aim"}, new List<string>() {"ntr", "aim"},
@ -119,9 +97,6 @@ namespace HeavenStudio.Games
public SpriteRenderer fg; public SpriteRenderer fg;
public SpriteRenderer bg; public SpriteRenderer bg;
Tween bgColorTween;
Tween fgColorTween;
[Header("Animators")] [Header("Animators")]
public Animator handAnimator; public Animator handAnimator;
@ -143,16 +118,17 @@ namespace HeavenStudio.Games
isThrowing = false; isThrowing = false;
coin = null; coin = null;
colorStart = defaultBgColor;
colorEnd = defaultBgColor;
colorStartF = defaultBgColor;
colorEndF = defaultBgColor;
BackgroundColorUpdate();
} }
private void Update() private void Update()
{ {
//nothing BackgroundColorUpdate();
}
private void LateUpdate()
{
//nothing
} }
public void TossCoin(double beat, int type, bool audienceReacting) public void TossCoin(double beat, int type, bool audienceReacting)
@ -230,37 +206,65 @@ namespace HeavenStudio.Games
coin.CanHit(false); coin.CanHit(false);
} }
public void ChangeBackgroundColor(Color color, float beats, bool isFg = false) private double colorStartBeat = -1;
private float colorLength = 0f;
private Color colorStart; //obviously put to the default color of the game
private Color colorEnd;
private Color colorStartF; //obviously put to the default color of the game
private Color colorEndF;
private Util.EasingFunction.Ease colorEase; //putting Util in case this game is using jukebox
//call this in update
private void BackgroundColorUpdate()
{ {
var seconds = Conductor.instance.secPerBeat * beats; float normalizedBeat = Mathf.Clamp01(Conductor.instance.GetPositionFromBeat(colorStartBeat, colorLength));
if(!isFg) var func = Util.EasingFunction.GetEasingFunction(colorEase);
{
if (bgColorTween != null)
bgColorTween.Kill(true);
} else
{
if (fgColorTween != null)
fgColorTween.Kill(true);
}
if (seconds == 0) float newR = func(colorStart.r, colorEnd.r, normalizedBeat);
float newG = func(colorStart.g, colorEnd.g, normalizedBeat);
float newB = func(colorStart.b, colorEnd.b, normalizedBeat);
bg.color = new Color(newR, newG, newB);
float newRF = func(colorStartF.r, colorEndF.r, normalizedBeat);
float newGF = func(colorStartF.g, colorEndF.g, normalizedBeat);
float newBF = func(colorStartF.b, colorEndF.b, normalizedBeat);
fg.color = new Color(newRF, newGF, newBF);
}
public void BackgroundColor(double beat, float length, Color colorStartSet, Color colorEndSet, Color colorStartSetF, Color colorEndSetF, int ease)
{
colorStartBeat = beat;
colorLength = length;
colorStart = colorStartSet;
colorEnd = colorEndSet;
colorStartF = colorStartSetF;
colorEndF = colorEndSetF;
colorEase = (Util.EasingFunction.Ease)ease;
}
//call this in OnPlay(double beat) and OnGameSwitch(double beat)
private void PersistColor(double beat)
{
var allEventsBeforeBeat = EventCaller.GetAllInGameManagerList("coinToss", new string[] { "fade background color" }).FindAll(x => x.beat < beat);
if (allEventsBeforeBeat.Count > 0)
{ {
if(!isFg) bg.color = color; allEventsBeforeBeat.Sort((x, y) => x.beat.CompareTo(y.beat)); //just in case
if (isFg) fg.color = color; var lastEvent = allEventsBeforeBeat[^1];
} BackgroundColor(lastEvent.beat, lastEvent.length, lastEvent["colorStart"], lastEvent["colorEnd"], lastEvent["colorStartF"], lastEvent["colorEndF"], lastEvent["ease"]);
else
{
if(!isFg) bgColorTween = bg.DOColor(color, seconds);
if(isFg) fgColorTween = fg.DOColor(color, seconds);
} }
} }
public void FadeBackgroundColor(Color start, Color end, float beats, bool isFg = false) public override void OnPlay(double beat)
{ {
ChangeBackgroundColor(start, 0f, isFg); PersistColor(beat);
ChangeBackgroundColor(end, beats, isFg); }
public override void OnGameSwitch(double beat)
{
PersistColor(beat);
} }
} }
} }

81
Assets/Scripts/Games/DrummingPractice/DrummingPractice.cs
View file

@ -56,15 +56,20 @@ namespace HeavenStudio.Games.Loaders
new Param("ease", EasingFunction.Ease.Linear, "Ease", "Which ease should the movement have?") new Param("ease", EasingFunction.Ease.Linear, "Ease", "Which ease should the movement have?")
} }
}, },
new GameAction("set background color", "Set Background Color") new GameAction("set background color", "Background Color")
{ {
function = delegate {var e = eventCaller.currentEntity; DrummingPractice.instance.SetBackgroundColor(e["colorA"], e["colorB"], e["colorC"]); }, function = delegate {var e = eventCaller.currentEntity;
defaultLength = 0.5f, DrummingPractice.instance.BackgroundColor(e.beat, e.length, e["colorAStart"], e["colorA"], e["colorBStart"], e["colorB"], e["colorC"], e["ease"]); },
defaultLength = 4f,
resizable = true,
parameters = new List<Param>() parameters = new List<Param>()
{ {
new Param("colorA", new Color(43/255f, 207/255f, 51/255f), "Color A", "The top-most color of the background gradient"), new Param("colorAStart", new Color(43/255f, 207/255f, 51/255f), "Color A Start", "The top-most color of the background gradient"),
new Param("colorB", new Color(1, 1, 1), "Color B", "The bottom-most color of the background gradient"), new Param("colorA", new Color(43/255f, 207/255f, 51/255f), "Color A End", "The top-most color of the background gradient"),
new Param("colorC", new Color(1, 247/255f, 0), "Streak Color", "The color of streaks that appear on a successful hit") new Param("colorBStart", new Color(1, 1, 1), "Color B Start", "The bottom-most color of the background gradient"),
new Param("colorB", new Color(1, 1, 1), "Color B End", "The bottom-most color of the background gradient"),
new Param("colorC", new Color(1, 247/255f, 0), "Streak Color", "The color of streaks that appear on a successful hit"),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease")
} }
} }
}, },
@ -133,6 +138,7 @@ namespace HeavenStudio.Games
{ {
EventCaller.instance.CallEvent(changeMii, true); EventCaller.instance.CallEvent(changeMii, true);
} }
PersistColor(beat);
} }
private void Update() private void Update()
@ -162,6 +168,8 @@ namespace HeavenStudio.Games
Color col = streak.color; Color col = streak.color;
streak.color = new Color(col.r, col.g, col.b, Mathf.Lerp(col.a, 0, 3.5f * Time.deltaTime)); streak.color = new Color(col.r, col.g, col.b, Mathf.Lerp(col.a, 0, 3.5f * Time.deltaTime));
} }
BackgroundColorUpdate();
} }
public void NPCDrummersEnterOrExit(double beat, float length, bool exit, int ease) public void NPCDrummersEnterOrExit(double beat, float length, bool exit, int ease)
@ -271,16 +279,67 @@ namespace HeavenStudio.Games
SetFaces(0); SetFaces(0);
} }
public void SetBackgroundColor(Color col1, Color col2, Color col3) private double colorStartBeat = -1;
private float colorLength = 0f;
private Color colorStart = new Color(43 / 255f, 207 / 255f, 51 / 255f); //obviously put to the default color of the game
private Color colorEnd = new Color(43 / 255f, 207 / 255f, 51 / 255f);
private Color colorStartB = Color.white; //obviously put to the default color of the game
private Color colorEndB = Color.white;
private Util.EasingFunction.Ease colorEase; //putting Util in case this game is using jukebox
//call this in update
private void BackgroundColorUpdate()
{ {
backgroundGradient.color = col1; float normalizedBeat = Mathf.Clamp01(Conductor.instance.GetPositionFromBeat(colorStartBeat, colorLength));
background.color = col2;
foreach(SpriteRenderer streak in streaks) var func = Util.EasingFunction.GetEasingFunction(colorEase);
float newR = func(colorStart.r, colorEnd.r, normalizedBeat);
float newG = func(colorStart.g, colorEnd.g, normalizedBeat);
float newB = func(colorStart.b, colorEnd.b, normalizedBeat);
backgroundGradient.color = new Color(newR, newG, newB);
float newRB = func(colorStartB.r, colorEndB.r, normalizedBeat);
float newGB = func(colorStartB.g, colorEndB.g, normalizedBeat);
float newBB = func(colorStartB.b, colorEndB.b, normalizedBeat);
background.color = new Color(newRB, newGB, newBB);
}
public void BackgroundColor(double beat, float length, Color colorStartSet, Color colorEndSet, Color colorStartSetB, Color colorEndSetB, Color setStreak, int ease)
{
colorStartBeat = beat;
colorLength = length;
colorStart = colorStartSet;
colorEnd = colorEndSet;
colorStartB = colorStartSetB;
colorEndB = colorEndSetB;
colorEase = (Util.EasingFunction.Ease)ease;
foreach (SpriteRenderer streak in streaks)
{ {
streak.color = new Color(col3.r, col3.g, col3.b, streak.color.a); streak.color = new Color(setStreak.r, setStreak.g, setStreak.b, streak.color.a);
} }
} }
//call this in OnPlay(double beat) and OnGameSwitch(double beat)
private void PersistColor(double beat)
{
var allEventsBeforeBeat = EventCaller.GetAllInGameManagerList("drummingPractice", new string[] { "set background color" }).FindAll(x => x.beat < beat);
if (allEventsBeforeBeat.Count > 0)
{
allEventsBeforeBeat.Sort((x, y) => x.beat.CompareTo(y.beat)); //just in case
var lastEvent = allEventsBeforeBeat[^1];
BackgroundColor(lastEvent.beat, lastEvent.length, lastEvent["colorAStart"], lastEvent["colorA"], lastEvent["colorBStart"], lastEvent["colorB"], lastEvent["colorC"], lastEvent["ease"]);
}
}
public override void OnPlay(double beat)
{
PersistColor(beat);
}
public void Streak() public void Streak()
{ {
foreach (SpriteRenderer streak in streaks) foreach (SpriteRenderer streak in streaks)

136
Assets/Scripts/Games/ForkLifter/ForkLifter.cs
View file

@ -4,8 +4,6 @@ using UnityEngine;
using HeavenStudio.Util; using HeavenStudio.Util;
using DG.Tweening;
namespace HeavenStudio.Games.Loaders namespace HeavenStudio.Games.Loaders
{ {
using static Minigames; using static Minigames;
@ -39,23 +37,23 @@ namespace HeavenStudio.Games.Loaders
}, },
new GameAction("color", "Background Color") new GameAction("color", "Background Color")
{ {
function = delegate { var e = eventCaller.currentEntity; ForkLifter.instance.FadeBackgroundColor(e["start"], e["end"], e.length, e["instant"]); }, function = delegate { var e = eventCaller.currentEntity; ForkLifter.instance.BackgroundColor(e.beat, e.length, e["start"], e["end"], e["ease"]); },
parameters = new List<Param>() parameters = new List<Param>()
{ {
new Param("start", Color.white, "Start Color", "The color to start fading from."), new Param("start", Color.white, "Start Color", "The color to start fading from."),
new Param("end", Color.white, "End Color", "The color to end the fade."), new Param("end", Color.white, "End Color", "The color to end the fade."),
new Param("instant", false, "Instant", "If checked, the background color will instantly change to the start color.") new Param("ease", Util.EasingFunction.Ease.Linear, "Ease")
}, },
resizable = true resizable = true
}, },
new GameAction("colorGrad", "Gradient Color") new GameAction("colorGrad", "Gradient Color")
{ {
function = delegate { var e = eventCaller.currentEntity; ForkLifter.instance.FadeGradientColor(e["start"], e["end"], e.length, e["instant"]); }, function = delegate { var e = eventCaller.currentEntity; ForkLifter.instance.BackgroundColorGrad(e.beat, e.length, e["start"], e["end"], e["ease"]); },
parameters = new List<Param>() parameters = new List<Param>()
{ {
new Param("start", Color.white, "Start Color", "The color to start fading from."), new Param("start", Color.white, "Start Color", "The color to start fading from."),
new Param("end", Color.white, "End Color", "The color to end the fade."), new Param("end", Color.white, "End Color", "The color to end the fade."),
new Param("instant", false, "Instant", "If checked, the gradient color will instantly change to the start color.") new Param("ease", Util.EasingFunction.Ease.Linear, "Ease")
}, },
resizable = true resizable = true
}, },
@ -134,11 +132,6 @@ namespace HeavenStudio.Games
[SerializeField] SpriteRenderer viewerCircle; [SerializeField] SpriteRenderer viewerCircle;
[SerializeField] SpriteRenderer playerShadow; [SerializeField] SpriteRenderer playerShadow;
[SerializeField] SpriteRenderer handShadow; [SerializeField] SpriteRenderer handShadow;
Tween bgColorTween;
Tween bgGradientColorTween;
Tween viewerCircleColorTween;
Tween playerShadowColorTween;
Tween handShadowColorTween;
public Sprite[] peaSprites; public Sprite[] peaSprites;
public Sprite[] peaHitSprites; public Sprite[] peaHitSprites;
@ -148,10 +141,16 @@ namespace HeavenStudio.Games
instance = this; instance = this;
} }
private void Update()
{
BackgroundColorUpdate();
}
public override void OnGameSwitch(double beat) public override void OnGameSwitch(double beat)
{ {
base.OnGameSwitch(beat); base.OnGameSwitch(beat);
ForkLifterHand.CheckNextFlick(); ForkLifterHand.CheckNextFlick();
PersistColor(beat);
} }
@ -180,61 +179,86 @@ namespace HeavenStudio.Games
fo.SetActive(true); fo.SetActive(true);
} }
public void ChangeBackgroundColor(Color color, float beats) private double colorStartBeat = -1;
private float colorLength = 0f;
private Color colorStart = Color.white; //obviously put to the default color of the game
private Color colorEnd = Color.white;
private Util.EasingFunction.Ease colorEase; //putting Util in case this game is using jukebox
private double colorStartBeatGrad = -1;
private float colorLengthGrad = 0f;
private Color colorStartGrad = Color.white; //obviously put to the default color of the game
private Color colorEndGrad = Color.white;
private Util.EasingFunction.Ease colorEaseGrad; //putting Util in case this game is using jukebox
//call this in update
private void BackgroundColorUpdate()
{ {
var seconds = Conductor.instance.secPerBeat * beats; float normalizedBeat = Mathf.Clamp01(Conductor.instance.GetPositionFromBeat(colorStartBeat, colorLength));
if (bgColorTween != null) var func = Util.EasingFunction.GetEasingFunction(colorEase);
bgColorTween.Kill(true);
if (viewerCircleColorTween != null)
viewerCircleColorTween.Kill(true);
if (handShadowColorTween != null) handShadowColorTween.Kill(true);
if (seconds == 0) float newR = func(colorStart.r, colorEnd.r, normalizedBeat);
float newG = func(colorStart.g, colorEnd.g, normalizedBeat);
float newB = func(colorStart.b, colorEnd.b, normalizedBeat);
bg.color = new Color(newR, newG, newB);
viewerCircle.color = new Color(newR, newG, newB);
handShadow.color = new Color(newR, newG, newB);
float normalizedBeatGrad = Mathf.Clamp01(Conductor.instance.GetPositionFromBeat(colorStartBeatGrad, colorLengthGrad));
var funcGrad = Util.EasingFunction.GetEasingFunction(colorEaseGrad);
float newRGrad = func(colorStartGrad.r, colorEndGrad.r, normalizedBeatGrad);
float newGGrad = func(colorStartGrad.g, colorEndGrad.g, normalizedBeatGrad);
float newBGrad = func(colorStartGrad.b, colorEndGrad.b, normalizedBeatGrad);
bgGradient.color = new Color(newRGrad, newGGrad, newBGrad);
playerShadow.color = new Color(newRGrad, newGGrad, newBGrad);
}
public void BackgroundColor(double beat, float length, Color colorStartSet, Color colorEndSet, int ease)
{
colorStartBeat = beat;
colorLength = length;
colorStart = colorStartSet;
colorEnd = colorEndSet;
colorEase = (Util.EasingFunction.Ease)ease;
}
public void BackgroundColorGrad(double beat, float length, Color colorStartSet, Color colorEndSet, int ease)
{
colorStartBeatGrad = beat;
colorLengthGrad = length;
colorStartGrad = colorStartSet;
colorEndGrad = colorEndSet;
colorEaseGrad = (Util.EasingFunction.Ease)ease;
}
//call this in OnPlay(double beat) and OnGameSwitch(double beat)
private void PersistColor(double beat)
{
var allEventsBeforeBeat = EventCaller.GetAllInGameManagerList("forkLifter", new string[] { "color" }).FindAll(x => x.beat < beat);
if (allEventsBeforeBeat.Count > 0)
{ {
bg.color = color; allEventsBeforeBeat.Sort((x, y) => x.beat.CompareTo(y.beat)); //just in case
viewerCircle.color = color; var lastEvent = allEventsBeforeBeat[^1];
handShadow.color = color; BackgroundColor(lastEvent.beat, lastEvent.length, lastEvent["start"], lastEvent["end"], lastEvent["ease"]);
} }
else
var allEventsBeforeBeatGrad = EventCaller.GetAllInGameManagerList("forkLifter", new string[] { "colorGrad" }).FindAll(x => x.beat < beat);
if (allEventsBeforeBeatGrad.Count > 0)
{ {
bgColorTween = bg.DOColor(color, seconds); allEventsBeforeBeatGrad.Sort((x, y) => x.beat.CompareTo(y.beat)); //just in case
handShadowColorTween = handShadow.DOColor(color, seconds); var lastEventGrad = allEventsBeforeBeatGrad[^1];
viewerCircleColorTween = viewerCircle.DOColor(color, seconds); BackgroundColorGrad(lastEventGrad.beat, lastEventGrad.length, lastEventGrad["start"], lastEventGrad["end"], lastEventGrad["ease"]);
} }
} }
public void FadeBackgroundColor(Color start, Color end, float beats, bool instant) public override void OnPlay(double beat)
{ {
ChangeBackgroundColor(start, 0f); PersistColor(beat);
if (!instant) ChangeBackgroundColor(end, beats);
}
public void ChangeGradientColor(Color color, float beats)
{
var seconds = Conductor.instance.secPerBeat * beats;
if (bgGradientColorTween != null)
bgGradientColorTween.Kill(true);
if (playerShadowColorTween != null) playerShadowColorTween.Kill(true);
if (seconds == 0)
{
bgGradient.color = color;
playerShadow.color = color;
}
else
{
bgGradientColorTween = bgGradient.DOColor(color, seconds);
playerShadowColorTween = playerShadow.DOColor(color, seconds);
}
}
public void FadeGradientColor(Color start, Color end, float beats, bool instant)
{
ChangeGradientColor(start, 0f);
if (!instant) ChangeGradientColor(end, beats);
} }
} }
} }

79
Assets/Scripts/Games/Kitties/Kitties.cs
View file

@ -62,12 +62,18 @@ namespace HeavenStudio.Games.Loaders
new GameAction("bgcolor", "Background Color") new GameAction("bgcolor", "Background Color")
{ {
function = delegate {Kitties.instance.BackgroundColor(eventCaller.currentEntity["color"]); }, function = delegate
defaultLength = .5f, {
var e = eventCaller.currentEntity;
Kitties.instance.BackgroundColor(e.beat, e.length, e["colorStart"], e["colorEnd"], e["ease"]);
},
defaultLength = 4,
resizable = true,
parameters = new List<Param>() parameters = new List<Param>()
{ {
new Param("color", Kitties.defaultBGColor, "Change BG Color", "Changes background color"), new Param("colorStart", Color.white, "Start Color"),
new Param("colorEnd", Color.white, "End Color"),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease")
} }
} }
}, },
@ -94,18 +100,6 @@ namespace HeavenStudio.Games
public Vector3[] positions; public Vector3[] positions;
public float[] rotationAngles; public float[] rotationAngles;
private static Color _defaultBGColor;
public static Color defaultBGColor
{
get
{
ColorUtility.TryParseHtmlString("#FFFFFF", out _defaultBGColor);
return _defaultBGColor;
}
}
public Color currentBGColor;
public enum SpawnType public enum SpawnType
{ {
Straight, Straight,
@ -124,7 +118,7 @@ namespace HeavenStudio.Games
// Update is called once per frame // Update is called once per frame
void Update() void Update()
{ {
BackgroundColorUpdate();
} }
public void Clap(bool isMice, bool isInverse, bool keepSpawned, double beat, int type) public void Clap(bool isMice, bool isInverse, bool keepSpawned, double beat, int type)
@ -449,10 +443,55 @@ namespace HeavenStudio.Games
player.canClap = true; player.canClap = true;
} }
public void BackgroundColor(Color color) private double colorStartBeat = -1;
private float colorLength = 0f;
private Color colorStart = Color.white; //obviously put to the default color of the game
private Color colorEnd = Color.white;
private Util.EasingFunction.Ease colorEase; //putting Util in case this game is using jukebox
//call this in update
private void BackgroundColorUpdate()
{ {
background.color = color; float normalizedBeat = Mathf.Clamp01(Conductor.instance.GetPositionFromBeat(colorStartBeat, colorLength));
currentBGColor = background.color;
var func = Util.EasingFunction.GetEasingFunction(colorEase);
float newR = func(colorStart.r, colorEnd.r, normalizedBeat);
float newG = func(colorStart.g, colorEnd.g, normalizedBeat);
float newB = func(colorStart.b, colorEnd.b, normalizedBeat);
background.color = new Color(newR, newG, newB);
}
public void BackgroundColor(double beat, float length, Color colorStartSet, Color colorEndSet, int ease)
{
colorStartBeat = beat;
colorLength = length;
colorStart = colorStartSet;
colorEnd = colorEndSet;
colorEase = (Util.EasingFunction.Ease)ease;
}
//call this in OnPlay(double beat) and OnGameSwitch(double beat)
private void PersistColor(double beat)
{
var allEventsBeforeBeat = EventCaller.GetAllInGameManagerList("kitties", new string[] { "bgcolor" }).FindAll(x => x.beat < beat);
if (allEventsBeforeBeat.Count > 0)
{
allEventsBeforeBeat.Sort((x, y) => x.beat.CompareTo(y.beat)); //just in case
var lastEvent = allEventsBeforeBeat[^1];
BackgroundColor(lastEvent.beat, lastEvent.length, lastEvent["colorStart"], lastEvent["colorEnd"], lastEvent["ease"]);
}
}
public override void OnPlay(double beat)
{
PersistColor(beat);
}
public override void OnGameSwitch(double beat)
{
PersistColor(beat);
} }
} }
} }

13
Assets/Scripts/Games/Lockstep/Lockstep.cs
View file

@ -231,6 +231,17 @@ namespace HeavenStudio.Games
bachEvents = EventCaller.GetAllInGameManagerList("lockstep", new string[] { "bach" }); bachEvents = EventCaller.GetAllInGameManagerList("lockstep", new string[] { "bach" });
} }
private void PersistColors(double beat)
{
var allEventsBeforeBeat = EventCaller.GetAllInGameManagerList("lockstep", new string[] { "" }).FindAll(x => x.beat < beat);
if (allEventsBeforeBeat.Count > 0)
{
allEventsBeforeBeat.Sort((x, y) => x.beat.CompareTo(y.beat));
var lastEvent = allEventsBeforeBeat[^1];
SetBackgroundColours(lastEvent["colorA"], lastEvent["colorB"], lastEvent["objColA"], lastEvent["objColB"], lastEvent["objColC"]);
}
}
private bool BachOnBeat(double beat) private bool BachOnBeat(double beat)
{ {
return bachEvents.Find(x => beat >= x.beat && beat < x.beat + x.length) != null; return bachEvents.Find(x => beat >= x.beat && beat < x.beat + x.length) != null;
@ -238,11 +249,13 @@ namespace HeavenStudio.Games
public override void OnGameSwitch(double beat) public override void OnGameSwitch(double beat)
{ {
QueueSwitchBGs(beat); QueueSwitchBGs(beat);
PersistColors(beat);
} }
public override void OnPlay(double beat) public override void OnPlay(double beat)
{ {
QueueSwitchBGs(beat); QueueSwitchBGs(beat);
PersistColors(beat);
} }
private void QueueSwitchBGs(double beat) private void QueueSwitchBGs(double beat)

63
Assets/Scripts/Games/OctopusMachine/OctopusMachine.cs
View file

@ -1,7 +1,6 @@
using HeavenStudio.Util; using HeavenStudio.Util;
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using DG.Tweening;
using UnityEngine; using UnityEngine;
using TMPro; using TMPro;
// using GhostlyGuy's Balls; // using GhostlyGuy's Balls;
@ -122,12 +121,12 @@ namespace HeavenStudio.Games.Loaders
{ {
function = delegate { function = delegate {
var e = eventCaller.currentEntity; var e = eventCaller.currentEntity;
OctopusMachine.instance.ChangeColor(e["color1"], e["color2"], e["octoColor"], e["squeezedColor"], e.length, e["bgInstant"]); OctopusMachine.instance.BackgroundColor(e.beat, e.length, e["color1"], e["color2"], e["octoColor"], e["squeezedColor"], e["ease"]);
}, },
parameters = new List<Param>() { parameters = new List<Param>() {
new Param("color1", new Color(1f, 0.87f, 0.24f), "Background Start Color", "Set the beginning background color"), new Param("color1", new Color(1f, 0.87f, 0.24f), "Background Start Color", "Set the beginning background color"),
new Param("color2", new Color(1f, 0.87f, 0.24f), "Background End Color", "Set the end background color"), new Param("color2", new Color(1f, 0.87f, 0.24f), "Background End Color", "Set the end background color"),
new Param("bgInstant", false, "Instant Background?", "Set the end background color instantly"), new Param("ease", Util.EasingFunction.Ease.Linear, "Ease"),
new Param("octoColor", new Color(0.97f, 0.235f, 0.54f), "Octopodes Color", "Set the octopodes' colors"), new Param("octoColor", new Color(0.97f, 0.235f, 0.54f), "Octopodes Color", "Set the octopodes' colors"),
new Param("squeezedColor", new Color(1f, 0f, 0f), "Squeezed Color", "Set the octopodes' colors when they're squeezed"), new Param("squeezedColor", new Color(1f, 0f, 0f), "Squeezed Color", "Set the octopodes' colors when they're squeezed"),
}, },
@ -184,7 +183,6 @@ namespace HeavenStudio.Games
[Header("Variables")] [Header("Variables")]
public bool hasMissed; public bool hasMissed;
public int bopStatus = 0; public int bopStatus = 0;
Tween bgColorTween;
int bopIterate = 0; int bopIterate = 0;
bool intervalStarted; bool intervalStarted;
bool autoAction; bool autoAction;
@ -218,7 +216,6 @@ namespace HeavenStudio.Games
private void Start() private void Start()
{ {
bg.color = backgroundColor;
foreach (var octo in octopodes) octo.AnimationColor(0); foreach (var octo in octopodes) octo.AnimationColor(0);
bopStatus = 0; bopStatus = 0;
} }
@ -239,6 +236,7 @@ namespace HeavenStudio.Games
private void Update() private void Update()
{ {
BackgroundColorUpdate();
if (queuePrepare) { if (queuePrepare) {
foreach (var octo in octopodes) octo.queuePrepare = true; foreach (var octo in octopodes) octo.queuePrepare = true;
if (Text.text is "Wrong! Try Again!" or "Good!") Text.text = ""; if (Text.text is "Wrong! Try Again!" or "Good!") Text.text = "";
@ -328,27 +326,60 @@ namespace HeavenStudio.Games
} }
} }
public void FadeBackgroundColor(Color color, float beats) private double colorStartBeat = -1;
private float colorLength = 0f;
private Color colorStart = new Color(1, 0.87f, 0.24f); //obviously put to the default color of the game
private Color colorEnd = new Color(1, 0.87f, 0.24f);
private Util.EasingFunction.Ease colorEase; //putting Util in case this game is using jukebox
//call this in update
private void BackgroundColorUpdate()
{ {
var seconds = Conductor.instance.secPerBeat * beats; float normalizedBeat = Mathf.Clamp01(Conductor.instance.GetPositionFromBeat(colorStartBeat, colorLength));
if (bgColorTween != null) var func = Util.EasingFunction.GetEasingFunction(colorEase);
bgColorTween.Kill(true);
if (seconds == 0) bg.color = color; float newR = func(colorStart.r, colorEnd.r, normalizedBeat);
else bgColorTween = bg.DOColor(color, seconds); float newG = func(colorStart.g, colorEnd.g, normalizedBeat);
float newB = func(colorStart.b, colorEnd.b, normalizedBeat);
bg.color = new Color(newR, newG, newB);
} }
public void ChangeColor(Color bgStart, Color bgEnd, Color octoColor, Color octoSqueezedColor, float beats, bool bgInstant) public void BackgroundColor(double beat, float length, Color colorStartSet, Color colorEndSet, Color octoColor, Color octoSqueezeColor, int ease)
{ {
FadeBackgroundColor(bgStart, 0f); colorStartBeat = beat;
if (!bgInstant) FadeBackgroundColor(bgEnd, beats); colorLength = length;
backgroundColor = bgEnd; colorStart = colorStartSet;
colorEnd = colorEndSet;
colorEase = (Util.EasingFunction.Ease)ease;
octopodesColor = octoColor; octopodesColor = octoColor;
octopodesSqueezedColor = octoSqueezedColor; octopodesSqueezedColor = octoSqueezeColor;
foreach (var octo in octopodes) octo.AnimationColor(octo.isSqueezed ? 1 : 0); foreach (var octo in octopodes) octo.AnimationColor(octo.isSqueezed ? 1 : 0);
} }
//call this in OnPlay(double beat) and OnGameSwitch(double beat)
private void PersistColor(double beat)
{
var allEventsBeforeBeat = EventCaller.GetAllInGameManagerList("octopusMachine", new string[] { "changeColor" }).FindAll(x => x.beat < beat);
if (allEventsBeforeBeat.Count > 0)
{
allEventsBeforeBeat.Sort((x, y) => x.beat.CompareTo(y.beat)); //just in case
var lastEvent = allEventsBeforeBeat[^1];
BackgroundColor(lastEvent.beat, lastEvent.length, lastEvent["color1"], lastEvent["color2"], lastEvent["octoColor"], lastEvent["squeezedColor"], lastEvent["ease"]);
}
}
public override void OnPlay(double beat)
{
PersistColor(beat);
}
public override void OnGameSwitch(double beat)
{
PersistColor(beat);
}
public void OctopusModifiers(double beat, float oct1x, float oct2x, float oct3x, float oct1y, float oct2y, float oct3y, bool oct1, bool oct2, bool oct3) public void OctopusModifiers(double beat, float oct1x, float oct2x, float oct3x, float oct1y, float oct2y, float oct3y, bool oct1, bool oct2, bool oct3)
{ {
octopodes[0].OctopusModifiers(oct1x, oct1y, oct1); octopodes[0].OctopusModifiers(oct1x, oct1y, oct1);

84
Assets/Scripts/Games/RhythmTweezers/RhythmTweezers.cs
View file

@ -4,7 +4,6 @@ using UnityEngine;
using System; using System;
using Starpelly; using Starpelly;
using DG.Tweening; using DG.Tweening;
using HeavenStudio.Util; using HeavenStudio.Util;
namespace HeavenStudio.Games.Loaders namespace HeavenStudio.Games.Loaders
@ -65,26 +64,19 @@ namespace HeavenStudio.Games.Loaders
new Param("type", RhythmTweezers.NoPeekSignType.Full, "Sign Type", "Which sign will be used?") new Param("type", RhythmTweezers.NoPeekSignType.Full, "Sign Type", "Which sign will be used?")
} }
}, },
new GameAction("fade background color", "Background Fade") new GameAction("fade background color", "Background Color")
{ {
function = delegate function = delegate
{ {
var e = eventCaller.currentEntity; var e = eventCaller.currentEntity;
if (e["instant"]) RhythmTweezers.instance.BackgroundColor(e.beat, e.length, e["colorA"], e["colorB"], e["ease"]);
{
RhythmTweezers.instance.ChangeBackgroundColor(e["colorA"], 0f);
}
else
{
RhythmTweezers.instance.FadeBackgroundColor(e["colorA"], e["colorB"], e.length);
}
}, },
resizable = true, resizable = true,
parameters = new List<Param>() parameters = new List<Param>()
{ {
new Param("colorA", Color.white, "Start Color", "The starting color in the fade"), new Param("colorA", Color.white, "Start Color", "The starting color in the fade"),
new Param("colorB", RhythmTweezers.defaultBgColor, "End Color", "The ending color in the fade"), new Param("colorB", RhythmTweezers.defaultBgColor, "End Color", "The ending color in the fade"),
new Param("instant", false, "Instant", "Instantly change color to start color?") new Param("ease", Util.EasingFunction.Ease.Linear, "Ease")
} }
}, },
new GameAction("altSmile", "Use Alt Smile") new GameAction("altSmile", "Use Alt Smile")
@ -108,16 +100,6 @@ namespace HeavenStudio.Games.Loaders
}, },
hidden = true, hidden = true,
}, },
new GameAction("set background color", "Background Colour")
{
function = delegate { var e = eventCaller.currentEntity; RhythmTweezers.instance.ChangeBackgroundColor(e["colorA"], 0f); },
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("colorA", RhythmTweezers.defaultBgColor, "Background Color", "The background color to change to")
},
hidden = true
},
}, },
new List<string>() {"agb", "repeat"}, new List<string>() {"agb", "repeat"},
"agbhair", "en", "agbhair", "en",
@ -179,9 +161,7 @@ namespace HeavenStudio.Games
public Sprite onionSprite; public Sprite onionSprite;
public Sprite potatoSprite; public Sprite potatoSprite;
Tween transitionTween;
bool transitioning = false; bool transitioning = false;
Tween bgColorTween;
private static Color _defaultOnionColor; private static Color _defaultOnionColor;
public static Color defaultOnionColor public static Color defaultOnionColor
@ -231,6 +211,8 @@ namespace HeavenStudio.Games
private void Awake() private void Awake()
{ {
instance = this; instance = this;
colorStart = defaultBgColor;
colorEnd = defaultBgColor;
if (crHandlerInstance != null && crHandlerInstance.queuedEvents.Count > 0) if (crHandlerInstance != null && crHandlerInstance.queuedEvents.Count > 0)
{ {
foreach (var crEvent in crHandlerInstance.queuedEvents) foreach (var crEvent in crHandlerInstance.queuedEvents)
@ -262,6 +244,7 @@ namespace HeavenStudio.Games
public override void OnPlay(double beat) public override void OnPlay(double beat)
{ {
crHandlerInstance = null; crHandlerInstance = null;
PersistColor(beat);
} }
private void OnDestroy() private void OnDestroy()
@ -474,6 +457,8 @@ namespace HeavenStudio.Games
} }
} }
Tween transitionTween;
const float vegDupeOffset = 16.7f; const float vegDupeOffset = 16.7f;
public void NextVegetable(double beat, int type, Color onionColor, Color potatoColor) public void NextVegetable(double beat, int type, Color onionColor, Color potatoColor)
{ {
@ -517,27 +502,45 @@ namespace HeavenStudio.Games
VegetableDupe.color = newColor; VegetableDupe.color = newColor;
} }
public void ChangeBackgroundColor(Color color, float beats) private double colorStartBeat = -1;
private float colorLength = 0f;
private Color colorStart = Color.white; //obviously put to the default color of the game
private Color colorEnd = Color.white;
private Util.EasingFunction.Ease colorEase; //putting Util in case this game is using jukebox
//call this in update
private void BackgroundColorUpdate()
{ {
var seconds = Conductor.instance.secPerBeat * beats; float normalizedBeat = Mathf.Clamp01(Conductor.instance.GetPositionFromBeat(colorStartBeat, colorLength));
if (bgColorTween != null) var func = Util.EasingFunction.GetEasingFunction(colorEase);
bgColorTween.Kill(true);
if (seconds == 0) float newR = func(colorStart.r, colorEnd.r, normalizedBeat);
{ float newG = func(colorStart.g, colorEnd.g, normalizedBeat);
bg.color = color; float newB = func(colorStart.b, colorEnd.b, normalizedBeat);
}
else bg.color = new Color(newR, newG, newB);
{
bgColorTween = bg.DOColor(color, seconds);
}
} }
public void FadeBackgroundColor(Color start, Color end, float beats) public void BackgroundColor(double beat, float length, Color colorStartSet, Color colorEndSet, int ease)
{ {
ChangeBackgroundColor(start, 0f); colorStartBeat = beat;
ChangeBackgroundColor(end, beats); colorLength = length;
colorStart = colorStartSet;
colorEnd = colorEndSet;
colorEase = (Util.EasingFunction.Ease)ease;
}
//call this in OnPlay(double beat) and OnGameSwitch(double beat)
private void PersistColor(double beat)
{
var allEventsBeforeBeat = EventCaller.GetAllInGameManagerList("rhythmTweezers", new string[] { "fade background color" }).FindAll(x => x.beat < beat);
if (allEventsBeforeBeat.Count > 0)
{
allEventsBeforeBeat.Sort((x, y) => x.beat.CompareTo(y.beat)); //just in case
var lastEvent = allEventsBeforeBeat[^1];
BackgroundColor(lastEvent.beat, lastEvent.length, lastEvent["colorA"], lastEvent["colorB"], lastEvent["ease"]);
}
} }
public static void PreNoPeeking(double beat, float length, int type) public static void PreNoPeeking(double beat, float length, int type)
@ -585,6 +588,8 @@ namespace HeavenStudio.Games
queuedPeeks.Clear(); queuedPeeks.Clear();
} }
} }
BackgroundColorUpdate();
} }
public override void OnGameSwitch(double beat) public override void OnGameSwitch(double beat)
@ -600,6 +605,7 @@ namespace HeavenStudio.Games
queuedIntervals.Clear(); queuedIntervals.Clear();
} }
} }
PersistColor(beat);
} }
private void ResetVegetable() private void ResetVegetable()

75
Assets/Scripts/Games/SeeSaw/SeeSaw.cs
View file

@ -171,8 +171,8 @@ namespace HeavenStudio.Games
[NonSerialized] public bool sawShouldBop; [NonSerialized] public bool sawShouldBop;
[NonSerialized] public bool seeShouldBop; [NonSerialized] public bool seeShouldBop;
GameEvent bop = new GameEvent(); GameEvent bop = new GameEvent();
double bgColorStartBeat; double bgColorStartBeat = -1;
float bgColorLength; float bgColorLength = 0;
Util.EasingFunction.Ease lastEase; Util.EasingFunction.Ease lastEase;
Color colorFrom; Color colorFrom;
Color colorTo; Color colorTo;
@ -195,13 +195,39 @@ namespace HeavenStudio.Games
private void Awake() private void Awake()
{ {
instance = this; instance = this;
if (allJumpEvents.Count > 0) return; colorFrom = defaultBGColor;
GrabJumpEvents(Conductor.instance.songPositionInBeatsAsDouble); colorTo = defaultBGColor;
colorFrom2 = defaultBGColorBottom;
colorTo2 = defaultBGColorBottom;
}
public override void OnPlay(double beat)
{
GrabJumpEvents(beat);
PersistColor(beat);
PersistColors(beat);
} }
public override void OnGameSwitch(double beat) public override void OnGameSwitch(double beat)
{ {
GrabJumpEvents(beat); GrabJumpEvents(beat);
PersistColor(beat);
PersistColors(beat);
}
private void PersistColors(double beat)
{
var allEventsBeforeBeat = EventCaller.GetAllInGameManagerList("seeSaw", new string[] { "recolor" }).FindAll(x => x.beat < beat);
if (allEventsBeforeBeat.Count > 0)
{
allEventsBeforeBeat.Sort((x, y) => x.beat.CompareTo(y.beat));
var e = allEventsBeforeBeat[^1];
ChangeMappingColor(e["fill"], e["outline"]);
}
else
{
ChangeMappingColor(Color.white, defaultOtherColor);
}
} }
private void Start() private void Start()
@ -271,25 +297,38 @@ namespace HeavenStudio.Games
} }
} }
private void PersistColor(double beat)
{
var allEventsBeforeBeat = EventCaller.GetAllInGameManagerList("seeSaw", new string[] { "changeBgColor" }).FindAll(x => x.beat < beat);
if (allEventsBeforeBeat.Count > 0)
{
allEventsBeforeBeat.Sort((x, y) => x.beat.CompareTo(y.beat)); //just in case
var lastEvent = allEventsBeforeBeat[^1];
ChangeColor(lastEvent.beat, lastEvent.length, lastEvent["colorFrom"], lastEvent["colorTo"], lastEvent["colorFrom2"], lastEvent["colorTo2"], lastEvent["ease"]);
}
}
private void BackgroundColorUpdate(Conductor cond)
{
float normalizedBeat = Mathf.Clamp01(cond.GetPositionFromBeat(bgColorStartBeat, bgColorLength));
Util.EasingFunction.Function func = Util.EasingFunction.GetEasingFunction(lastEase);
float newColorR = func(colorFrom.r, colorTo.r, normalizedBeat);
float newColorG = func(colorFrom.g, colorTo.g, normalizedBeat);
float newColorB = func(colorFrom.b, colorTo.b, normalizedBeat);
bgHigh.color = new Color(newColorR, newColorG, newColorB);
gradient.color = new Color(newColorR, newColorG, newColorB);
newColorR = func(colorFrom2.r, colorTo2.r, normalizedBeat);
newColorG = func(colorFrom2.g, colorTo2.g, normalizedBeat);
newColorB = func(colorFrom2.b, colorTo2.b, normalizedBeat);
bgLow.color = new Color(newColorR, newColorG, newColorB);
}
private void Update() private void Update()
{ {
var cond = Conductor.instance; var cond = Conductor.instance;
if (cond.isPlaying && !cond.isPaused) if (cond.isPlaying && !cond.isPaused)
{ {
float normalizedBeat = cond.GetPositionFromBeat(bgColorStartBeat, bgColorLength); BackgroundColorUpdate(cond);
if (normalizedBeat > 0 && normalizedBeat <= 1)
{
Util.EasingFunction.Function func = Util.EasingFunction.GetEasingFunction(lastEase);
float newColorR = func(colorFrom.r, colorTo.r, normalizedBeat);
float newColorG = func(colorFrom.g, colorTo.g, normalizedBeat);
float newColorB = func(colorFrom.b, colorTo.b, normalizedBeat);
bgHigh.color = new Color(newColorR, newColorG, newColorB);
gradient.color = new Color(newColorR, newColorG, newColorB);
newColorR = func(colorFrom2.r, colorTo2.r, normalizedBeat);
newColorG = func(colorFrom2.g, colorTo2.g, normalizedBeat);
newColorB = func(colorFrom2.b, colorTo2.b, normalizedBeat);
bgLow.color = new Color(newColorR, newColorG, newColorB);
}
if (allJumpEvents.Count > 0 && !(see.dead || saw.dead)) if (allJumpEvents.Count > 0 && !(see.dead || saw.dead))
{ {
if (currentJumpIndex < allJumpEvents.Count && currentJumpIndex >= 0) if (currentJumpIndex < allJumpEvents.Count && currentJumpIndex >= 0)

63
Assets/Scripts/Games/SpaceDance/SpaceDance.cs
View file

@ -2,7 +2,6 @@ using HeavenStudio.Util;
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using UnityEngine; using UnityEngine;
using DG.Tweening;
using HeavenStudio.Common; using HeavenStudio.Common;
namespace HeavenStudio.Games.Loaders namespace HeavenStudio.Games.Loaders
@ -58,14 +57,14 @@ namespace HeavenStudio.Games.Loaders
}, },
new GameAction("changeBG", "Change Background Color") new GameAction("changeBG", "Change Background Color")
{ {
function = delegate {var e = eventCaller.currentEntity; SpaceDance.instance.FadeBackgroundColor(e["start"], e["end"], e.length, e["toggle"]); }, function = delegate {var e = eventCaller.currentEntity; SpaceDance.instance.BackgroundColor(e.beat, e.length, e["start"], e["end"], e["ease"]); },
defaultLength = 1f, defaultLength = 1f,
resizable = true, resizable = true,
parameters = new List<Param>() parameters = new List<Param>()
{ {
new Param("start", SpaceDance.defaultBGColor, "Start Color", "The start color for the fade or the color that will be switched to if -instant- is ticked on."), new Param("start", SpaceDance.defaultBGColor, "Start Color", "The start color for the fade or the color that will be switched to if -instant- is ticked on."),
new Param("end", SpaceDance.defaultBGColor, "End Color", "The end color for the fade."), new Param("end", SpaceDance.defaultBGColor, "End Color", "The end color for the fade."),
new Param("toggle", false, "Instant", "Should the background instantly change color?") new Param("ease", Util.EasingFunction.Ease.Linear, "Ease")
} }
}, },
new GameAction("bop", "Bop") new GameAction("bop", "Bop")
@ -135,7 +134,6 @@ namespace HeavenStudio.Games
Talk = 1, Talk = 1,
Sniff = 2 Sniff = 2
} }
Tween bgColorTween;
[SerializeField] SpriteRenderer bg; [SerializeField] SpriteRenderer bg;
[SerializeField] Animator shootingStarAnim; [SerializeField] Animator shootingStarAnim;
public Animator DancerP; public Animator DancerP;
@ -170,12 +168,15 @@ namespace HeavenStudio.Games
void Awake() void Awake()
{ {
instance = this; instance = this;
colorStart = defaultBGColor;
colorEnd = defaultBGColor;
} }
// Update is called once per frame // Update is called once per frame
void Update() void Update()
{ {
var cond = Conductor.instance; var cond = Conductor.instance;
BackgroundColorUpdate();
if (cond.isPlaying && !cond.isPaused) if (cond.isPlaying && !cond.isPaused)
{ {
scroll.NormalizedX -= xBaseSpeed * xScrollMultiplier * Time.deltaTime; scroll.NormalizedX -= xBaseSpeed * xScrollMultiplier * Time.deltaTime;
@ -633,27 +634,55 @@ namespace HeavenStudio.Games
Gramps.DoScaledAnimationAsync("GrampsBop", 0.5f); Gramps.DoScaledAnimationAsync("GrampsBop", 0.5f);
} }
public void ChangeBackgroundColor(Color color, float beats) private double colorStartBeat = -1;
private float colorLength = 0f;
private Color colorStart; //obviously put to the default color of the game
private Color colorEnd;
private Util.EasingFunction.Ease colorEase; //putting Util in case this game is using jukebox
//call this in update
private void BackgroundColorUpdate()
{ {
var seconds = Conductor.instance.secPerBeat * beats; float normalizedBeat = Mathf.Clamp01(Conductor.instance.GetPositionFromBeat(colorStartBeat, colorLength));
if (bgColorTween != null) var func = Util.EasingFunction.GetEasingFunction(colorEase);
bgColorTween.Kill(true);
if (seconds == 0) float newR = func(colorStart.r, colorEnd.r, normalizedBeat);
float newG = func(colorStart.g, colorEnd.g, normalizedBeat);
float newB = func(colorStart.b, colorEnd.b, normalizedBeat);
bg.color = new Color(newR, newG, newB);
}
public void BackgroundColor(double beat, float length, Color colorStartSet, Color colorEndSet, int ease)
{
colorStartBeat = beat;
colorLength = length;
colorStart = colorStartSet;
colorEnd = colorEndSet;
colorEase = (Util.EasingFunction.Ease)ease;
}
//call this in OnPlay(double beat) and OnGameSwitch(double beat)
private void PersistColor(double beat)
{
var allEventsBeforeBeat = EventCaller.GetAllInGameManagerList("spaceDance", new string[] { "changeBG" }).FindAll(x => x.beat < beat);
if (allEventsBeforeBeat.Count > 0)
{ {
bg.color = color; allEventsBeforeBeat.Sort((x, y) => x.beat.CompareTo(y.beat)); //just in case
} var lastEvent = allEventsBeforeBeat[^1];
else BackgroundColor(lastEvent.beat, lastEvent.length, lastEvent["start"], lastEvent["end"], lastEvent["ease"]);
{
bgColorTween = bg.DOColor(color, seconds);
} }
} }
public void FadeBackgroundColor(Color start, Color end, float beats, bool instant) public override void OnPlay(double beat)
{ {
ChangeBackgroundColor(start, 0f); PersistColor(beat);
if (!instant) ChangeBackgroundColor(end, beats); }
public override void OnGameSwitch(double beat)
{
PersistColor(beat);
} }
public void JustRight(PlayerActionEvent caller, float state) public void JustRight(PlayerActionEvent caller, float state)

76
Assets/Scripts/Games/SpaceSoccer/SpaceSoccer.cs
View file

@ -1,7 +1,6 @@
using System.Collections; using System.Collections;
using System.Collections.Generic; using System.Collections.Generic;
using UnityEngine; using UnityEngine;
using DG.Tweening;
using HeavenStudio.Util; using HeavenStudio.Util;
namespace HeavenStudio.Games.Loaders namespace HeavenStudio.Games.Loaders
@ -81,7 +80,7 @@ namespace HeavenStudio.Games.Loaders
}, },
new GameAction("changeBG", "Change Background Color") new GameAction("changeBG", "Change Background Color")
{ {
function = delegate {var e = eventCaller.currentEntity; SpaceSoccer.instance.FadeBackgroundColor(e["start"], e["end"], e["startDots"], e["endDots"], e.length, e["toggle"]); }, function = delegate {var e = eventCaller.currentEntity; SpaceSoccer.instance.BackgroundColor(e.beat, e.length, e["start"], e["end"], e["startDots"], e["endDots"], e["ease"]); },
defaultLength = 1f, defaultLength = 1f,
resizable = true, resizable = true,
parameters = new List<Param>() parameters = new List<Param>()
@ -90,7 +89,7 @@ namespace HeavenStudio.Games.Loaders
new Param("end", SpaceSoccer.defaultBGColor, "End Color", "The end color for the fade."), new Param("end", SpaceSoccer.defaultBGColor, "End Color", "The end color for the fade."),
new Param("startDots", Color.white, "Start Color (Dots)", "The start color for the fade or the color that will be switched to if -instant- is ticked on."), new Param("startDots", Color.white, "Start Color (Dots)", "The start color for the fade or the color that will be switched to if -instant- is ticked on."),
new Param("endDots", Color.white, "End Color (Dots)", "The end color for the fade."), new Param("endDots", Color.white, "End Color (Dots)", "The end color for the fade."),
new Param("toggle", false, "Instant", "Should the background instantly change color?") new Param("ease", Util.EasingFunction.Ease.Linear, "Ease")
} }
}, },
new GameAction("scroll", "Scrolling Background") new GameAction("scroll", "Scrolling Background")
@ -206,8 +205,6 @@ namespace HeavenStudio.Games
float yScrollMultiplier = 0.3f; float yScrollMultiplier = 0.3f;
[SerializeField] private float xBaseSpeed = 1; [SerializeField] private float xBaseSpeed = 1;
[SerializeField] private float yBaseSpeed = 1; [SerializeField] private float yBaseSpeed = 1;
Tween bgColorTween;
Tween dotColorTween;
#region Space Kicker Position Easing #region Space Kicker Position Easing
float easeBeat; float easeBeat;
float easeLength; float easeLength;
@ -226,6 +223,8 @@ namespace HeavenStudio.Games
private void Awake() private void Awake()
{ {
instance = this; instance = this;
colorStart = defaultBGColor;
colorEnd = defaultBGColor;
} }
new void OnDrawGizmos() new void OnDrawGizmos()
@ -243,6 +242,7 @@ namespace HeavenStudio.Games
private void Update() private void Update()
{ {
var cond = Conductor.instance; var cond = Conductor.instance;
BackgroundColorUpdate();
backgroundSprite.NormalizedX -= xBaseSpeed * xScrollMultiplier * Time.deltaTime; backgroundSprite.NormalizedX -= xBaseSpeed * xScrollMultiplier * Time.deltaTime;
backgroundSprite.NormalizedY += yBaseSpeed * yScrollMultiplier * Time.deltaTime; backgroundSprite.NormalizedY += yBaseSpeed * yScrollMultiplier * Time.deltaTime;
@ -324,6 +324,8 @@ namespace HeavenStudio.Games
Dispense(entity.beat, isOnGameSwitchBeat && !entity["toggle"], false, isOnGameSwitchBeat && entity["down"]); Dispense(entity.beat, isOnGameSwitchBeat && !entity["toggle"], false, isOnGameSwitchBeat && entity["down"]);
break; break;
} }
PersistColor(beat);
} }
public SuperCurveObject.Path GetPath(string name) public SuperCurveObject.Path GetPath(string name)
@ -485,32 +487,60 @@ namespace HeavenStudio.Games
}, forcePlay:true); }, forcePlay:true);
} }
public void ChangeBackgroundColor(Color color, Color dotColor, float beats) private double colorStartBeat = -1;
private float colorLength = 0f;
private Color colorStart; //obviously put to the default color of the game
private Color colorEnd;
private Color colorStartDot = Color.white; //obviously put to the default color of the game
private Color colorEndDot = Color.white;
private Util.EasingFunction.Ease colorEase; //putting Util in case this game is using jukebox
//call this in update
private void BackgroundColorUpdate()
{ {
var seconds = Conductor.instance.secPerBeat * beats; float normalizedBeat = Mathf.Clamp01(Conductor.instance.GetPositionFromBeat(colorStartBeat, colorLength));
if (bgColorTween != null) var func = Util.EasingFunction.GetEasingFunction(colorEase);
bgColorTween.Kill(true);
if (dotColorTween != null)
dotColorTween.Kill(true);
if (seconds == 0) float newR = func(colorStart.r, colorEnd.r, normalizedBeat);
float newG = func(colorStart.g, colorEnd.g, normalizedBeat);
float newB = func(colorStart.b, colorEnd.b, normalizedBeat);
bg.color = new Color(newR, newG, newB);
float newRDot = func(colorStartDot.r, colorEndDot.r, normalizedBeat);
float newGDot = func(colorStartDot.g, colorEndDot.g, normalizedBeat);
float newBDot = func(colorStartDot.b, colorEndDot.b, normalizedBeat);
bgImage.color = new Color(newRDot, newGDot, newBDot);
}
public void BackgroundColor(double beat, float length, Color colorStartSet, Color colorEndSet, Color colorStartDotSet, Color colorEndDotSet, int ease)
{
colorStartBeat = beat;
colorLength = length;
colorStart = colorStartSet;
colorEnd = colorEndSet;
colorStartDot = colorEndDotSet;
colorEndDot = colorEndDotSet;
colorEase = (Util.EasingFunction.Ease)ease;
}
//call this in OnPlay(double beat) and OnGameSwitch(double beat)
private void PersistColor(double beat)
{
var allEventsBeforeBeat = EventCaller.GetAllInGameManagerList("kitties", new string[] { "bgcolor" }).FindAll(x => x.beat < beat);
if (allEventsBeforeBeat.Count > 0)
{ {
bg.color = color; allEventsBeforeBeat.Sort((x, y) => x.beat.CompareTo(y.beat)); //just in case
bgImage.color = dotColor; var lastEvent = allEventsBeforeBeat[^1];
} BackgroundColor(lastEvent.beat, lastEvent.length, lastEvent["start"], lastEvent["end"], lastEvent["startDots"], lastEvent["endDots"], lastEvent["ease"]);
else
{
bgColorTween = bg.DOColor(color, seconds);
dotColorTween = bgImage.DOColor(dotColor, seconds);
} }
} }
public void FadeBackgroundColor(Color start, Color end, Color startDot, Color endDot, float beats, bool instant) public override void OnPlay(double beat)
{ {
ChangeBackgroundColor(start, startDot, 0f); PersistColor(beat);
if (!instant) ChangeBackgroundColor(end, endDot, beats);
} }
} }
} }

75
Assets/Scripts/Games/Tambourine/Tambourine.cs
View file

@ -2,7 +2,6 @@ using HeavenStudio.Util;
using System; using System;
using System.Collections.Generic; using System.Collections.Generic;
using UnityEngine; using UnityEngine;
using DG.Tweening;
using Jukebox; using Jukebox;
namespace HeavenStudio.Games.Loaders namespace HeavenStudio.Games.Loaders
@ -60,27 +59,16 @@ namespace HeavenStudio.Games.Loaders
}, },
new GameAction("fade background", "Background Color") new GameAction("fade background", "Background Color")
{ {
function = delegate {var e = eventCaller.currentEntity; Tambourine.instance.FadeBackgroundColor(e["colorA"], e["colorB"], e.length, e["instant"]); }, function = delegate {var e = eventCaller.currentEntity; Tambourine.instance.BackgroundColor(e.beat, e.length, e["colorStart"], e["colorEnd"], e["ease"]); },
defaultLength = 4f, defaultLength = 4f,
resizable = true, resizable = true,
parameters = new List<Param>() parameters = new List<Param>()
{ {
new Param("colorA", Color.white, "Start Color", "The starting color of the fade."), new Param("colorStart", Color.white, "Start Color", "The starting color of the fade."),
new Param("colorB", Tambourine.defaultBGColor, "End Color", "The ending color of the fade."), new Param("colorEnd", Tambourine.defaultBGColor, "End Color", "The ending color of the fade."),
new Param("instant", false, "Instant", "Instantly set the color of the background to the start color?") new Param("ease", Util.EasingFunction.Ease.Linear, "Ease")
} }
}, },
//backwards-compatibility
new GameAction("set background color", "Background Color")
{
function = delegate {var e = eventCaller.currentEntity; Tambourine.instance.ChangeBackgroundColor(e["colorA"], 0f); },
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("colorA", Tambourine.defaultBGColor, "Background Color", "The background color to change to.")
},
hidden = true
},
}, },
new List<string>() {"rvl", "repeat"}, new List<string>() {"rvl", "repeat"},
"rvldrum", "en", "rvldrum", "en",
@ -119,8 +107,6 @@ namespace HeavenStudio.Games
bool frogPresent; bool frogPresent;
bool monkeyGoBop; bool monkeyGoBop;
bool handsGoBop; bool handsGoBop;
Tween bgColorTween;
public GameEvent bop = new GameEvent(); public GameEvent bop = new GameEvent();
public enum WhoBops public enum WhoBops
@ -140,10 +126,13 @@ namespace HeavenStudio.Games
frogAnimator.Play("FrogExited", 0, 0); frogAnimator.Play("FrogExited", 0, 0);
handsAnimator.Play("Idle", 0, 0); handsAnimator.Play("Idle", 0, 0);
monkeyAnimator.Play("MonkeyIdle", 0, 0); monkeyAnimator.Play("MonkeyIdle", 0, 0);
colorStart = defaultBGColor;
colorEnd = defaultBGColor;
} }
void Update() void Update()
{ {
BackgroundColorUpdate();
if (Conductor.instance.ReportBeat(ref bop.lastReportedBeat, bop.startBeat % 1)) if (Conductor.instance.ReportBeat(ref bop.lastReportedBeat, bop.startBeat % 1))
{ {
if (monkeyGoBop) if (monkeyGoBop)
@ -228,6 +217,7 @@ namespace HeavenStudio.Games
} }
queuedIntervals.Clear(); queuedIntervals.Clear();
} }
PersistColor(beat);
} }
private struct QueuedInterval private struct QueuedInterval
@ -454,27 +444,50 @@ namespace HeavenStudio.Games
} }
} }
public void ChangeBackgroundColor(Color color, float beats) private double colorStartBeat = -1;
private float colorLength = 0f;
private Color colorStart = Color.white; //obviously put to the default color of the game
private Color colorEnd = Color.white;
private Util.EasingFunction.Ease colorEase; //putting Util in case this game is using jukebox
//call this in update
private void BackgroundColorUpdate()
{ {
var seconds = Conductor.instance.secPerBeat * beats; float normalizedBeat = Mathf.Clamp01(Conductor.instance.GetPositionFromBeat(colorStartBeat, colorLength));
if (bgColorTween != null) var func = Util.EasingFunction.GetEasingFunction(colorEase);
bgColorTween.Kill(true);
if (seconds == 0) float newR = func(colorStart.r, colorEnd.r, normalizedBeat);
float newG = func(colorStart.g, colorEnd.g, normalizedBeat);
float newB = func(colorStart.b, colorEnd.b, normalizedBeat);
bg.color = new Color(newR, newG, newB);
}
public void BackgroundColor(double beat, float length, Color colorStartSet, Color colorEndSet, int ease)
{
colorStartBeat = beat;
colorLength = length;
colorStart = colorStartSet;
colorEnd = colorEndSet;
colorEase = (Util.EasingFunction.Ease)ease;
}
//call this in OnPlay(double beat) and OnGameSwitch(double beat)
private void PersistColor(double beat)
{
var allEventsBeforeBeat = EventCaller.GetAllInGameManagerList("tambourine", new string[] { "fade background" }).FindAll(x => x.beat < beat);
if (allEventsBeforeBeat.Count > 0)
{ {
bg.color = color; allEventsBeforeBeat.Sort((x, y) => x.beat.CompareTo(y.beat)); //just in case
} var lastEvent = allEventsBeforeBeat[^1];
else BackgroundColor(lastEvent.beat, lastEvent.length, lastEvent["colorStart"], lastEvent["colorEnd"], lastEvent["ease"]);
{
bgColorTween = bg.DOColor(color, seconds);
} }
} }
public void FadeBackgroundColor(Color start, Color end, float beats, bool instant) public override void OnPlay(double beat)
{ {
ChangeBackgroundColor(start, 0f); PersistColor(beat);
if (!instant) ChangeBackgroundColor(end, beats);
} }
public void SummonFrog() public void SummonFrog()

63
Assets/Scripts/Games/TossBoys/TossBoys.cs
View file

@ -2,7 +2,6 @@ using System.Collections;
using System.Collections.Generic; using System.Collections.Generic;
using UnityEngine; using UnityEngine;
using HeavenStudio.Util; using HeavenStudio.Util;
using DG.Tweening;
using Jukebox; using Jukebox;
namespace HeavenStudio.Games.Loaders namespace HeavenStudio.Games.Loaders
@ -81,14 +80,14 @@ namespace HeavenStudio.Games.Loaders
}, },
new GameAction("changeBG", "Change Background Color") new GameAction("changeBG", "Change Background Color")
{ {
function = delegate {var e = eventCaller.currentEntity; TossBoys.instance.FadeBackgroundColor(e["start"], e["end"], e.length, e["toggle"]); }, function = delegate {var e = eventCaller.currentEntity; TossBoys.instance.BackgroundColor(e.beat, e.length, e["start"], e["end"], e["ease"]); },
defaultLength = 1f, defaultLength = 1f,
resizable = true, resizable = true,
parameters = new List<Param>() parameters = new List<Param>()
{ {
new Param("start", TossBoys.defaultBGColor, "Start Color", "The start color for the fade or the color that will be switched to if -instant- is ticked on."), new Param("start", TossBoys.defaultBGColor, "Start Color", "The start color for the fade or the color that will be switched to if -instant- is ticked on."),
new Param("end", TossBoys.defaultBGColor, "End Color", "The end color for the fade."), new Param("end", TossBoys.defaultBGColor, "End Color", "The end color for the fade."),
new Param("toggle", false, "Instant", "Should the background instantly change color?") new Param("ease", Util.EasingFunction.Ease.Linear, "Ease")
} }
}, },
}, },
@ -140,7 +139,6 @@ namespace HeavenStudio.Games
[SerializeField] SpriteRenderer bg; [SerializeField] SpriteRenderer bg;
[Header("Properties")] [Header("Properties")]
Tween bgColorTween;
[SerializeField] SuperCurveObject.Path[] ballPaths; [SerializeField] SuperCurveObject.Path[] ballPaths;
WhichTossKid lastReceiver = WhichTossKid.None; WhichTossKid lastReceiver = WhichTossKid.None;
WhichTossKid currentReceiver = WhichTossKid.None; WhichTossKid currentReceiver = WhichTossKid.None;
@ -155,6 +153,8 @@ namespace HeavenStudio.Games
private void Awake() private void Awake()
{ {
instance = this; instance = this;
colorStart = defaultBGColor;
colorEnd = defaultBGColor;
} }
new void OnDrawGizmos() new void OnDrawGizmos()
@ -184,6 +184,7 @@ namespace HeavenStudio.Games
private void Update() private void Update()
{ {
var cond = Conductor.instance; var cond = Conductor.instance;
BackgroundColorUpdate();
if (cond.isPlaying && !cond.isPaused) if (cond.isPlaying && !cond.isPaused)
{ {
if (cond.ReportBeat(ref bop.lastReportedBeat, bop.startBeat % 1)) if (cond.ReportBeat(ref bop.lastReportedBeat, bop.startBeat % 1))
@ -208,27 +209,55 @@ namespace HeavenStudio.Games
} }
} }
public void ChangeBackgroundColor(Color color, float beats) private double colorStartBeat = -1;
private float colorLength = 0f;
private Color colorStart = Color.white; //obviously put to the default color of the game
private Color colorEnd = Color.white;
private Util.EasingFunction.Ease colorEase; //putting Util in case this game is using jukebox
//call this in update
private void BackgroundColorUpdate()
{ {
var seconds = Conductor.instance.secPerBeat * beats; float normalizedBeat = Mathf.Clamp01(Conductor.instance.GetPositionFromBeat(colorStartBeat, colorLength));
if (bgColorTween != null) var func = Util.EasingFunction.GetEasingFunction(colorEase);
bgColorTween.Kill(true);
if (seconds == 0) float newR = func(colorStart.r, colorEnd.r, normalizedBeat);
float newG = func(colorStart.g, colorEnd.g, normalizedBeat);
float newB = func(colorStart.b, colorEnd.b, normalizedBeat);
bg.color = new Color(newR, newG, newB);
}
public void BackgroundColor(double beat, float length, Color colorStartSet, Color colorEndSet, int ease)
{
colorStartBeat = beat;
colorLength = length;
colorStart = colorStartSet;
colorEnd = colorEndSet;
colorEase = (Util.EasingFunction.Ease)ease;
}
//call this in OnPlay(double beat) and OnGameSwitch(double beat)
private void PersistColor(double beat)
{
var allEventsBeforeBeat = EventCaller.GetAllInGameManagerList("tossBoys", new string[] { "changeBG" }).FindAll(x => x.beat < beat);
if (allEventsBeforeBeat.Count > 0)
{ {
bg.color = color; allEventsBeforeBeat.Sort((x, y) => x.beat.CompareTo(y.beat)); //just in case
} var lastEvent = allEventsBeforeBeat[^1];
else BackgroundColor(lastEvent.beat, lastEvent.length, lastEvent["start"], lastEvent["end"], lastEvent["ease"]);
{
bgColorTween = bg.DOColor(color, seconds);
} }
} }
public void FadeBackgroundColor(Color start, Color end, float beats, bool instant) public override void OnPlay(double beat)
{ {
ChangeBackgroundColor(start, 0f); PersistColor(beat);
if (!instant) ChangeBackgroundColor(end, beats); }
public override void OnGameSwitch(double beat)
{
PersistColor(beat);
} }
#region Bop #region Bop