Mirrors/HeavenStudio
1
0
Fork 0
mirror of https://github.com/RHeavenStudio/HeavenStudio.git synced 2025-06-13 01:17:38 +02:00
Code Issues Packages Projects Releases Wiki Activity

Sick Beats Fixed (#788)

Browse Source 
* Sick Beats (WIP)

* sfx

* I wish create ScheduleMissableInput sometime

* deleted:    Assets/Resources/Sprites/Games/SickBeats/Animations/virus/virusCome.anim

* Simple Flick

* ScheduleMissableInput
This commit is contained in:
フマジメ
2024-03-14 01:47:40 +09:00
committed by GitHub
parent 4aca38009e
commit 31f4b1126e
111 changed files with 1192 additions and 631 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
Assets/Scripts/Games/PlayerActionEvent.cs
View File

@ -46,6 +46,8 @@ namespace HeavenStudio.Games
public bool countsForAccuracy = true; //Indicates if the input counts for the accuracy or not. If set to false, it'll not be counted in the accuracy calculation
public bool missable = false; //Indicates if the miss input counts for the accuracy or not. If set to true, it'll not be counted in the accuracy calculation
public void setHitCallback(ActionEventCallbackState OnHit)
{
this.OnHit = OnHit;
@ -332,7 +334,7 @@ namespace HeavenStudio.Games
OnMiss(this);
}
if (countsForAccuracy && gm.canInput && !(noAutoplay || autoplayOnly))
if (countsForAccuracy && !missable && gm.canInput && !(noAutoplay || autoplayOnly))
{
gm.ScoreInputAccuracy(startBeat + timer, 0, true, 2.0, weight, false);
GoForAPerfect.instance.Miss();

216
Assets/Scripts/Games/SickBeats/SickBeats.cs
View File

@ -25,53 +25,27 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("toggle2", true, "Bop", "Toggle if Boss should bop for the duration of this event."),
new Param("toggle", false, "Bop (Auto)", "Toggle if the man should automatically bop until another Bop event is reached.")
new Param("toggle2", true, "Bop", "Toggle if the doctor should bop for the duration of this event."),
new Param("toggle", false, "Bop (Auto)", "Toggle if the doctor should automatically bop until another Bop event is reached.")
}
},
new GameAction("virusLeft", "Virus (Right)")
new GameAction("virus", "Move Virus")
{
function = delegate { var e = eventCaller.currentEntity; SickBeats.instance.PresenceVirus(e.beat, (int)SickBeats.Direction.Right, e["type"]); },
function = delegate { var e = eventCaller.currentEntity; SickBeats.instance.MoveVirus(e.beat, e["direction"], e["type"]); },
parameters = new List<Param>()
{
new Param("type", SickBeats.VirusType.Blue, "Type", "Determine virus type"),
new Param("direction", SickBeats.Direction.Right, "Direction", "Determine which direction the virus will spawn from."),
new Param("type", SickBeats.VirusType.Blue, "Type", "Determine virus type."),
},
defaultLength = 4f,
},
new GameAction("virusUp", "Virus (Up)")
{
function = delegate { var e = eventCaller.currentEntity; SickBeats.instance.PresenceVirus(e.beat, (int)SickBeats.Direction.Up, e["type"]); },
parameters = new List<Param>()
{
new Param("type", SickBeats.VirusType.Blue, "Type", "Determine virus type"),
},
defaultLength = 6f,
},
new GameAction("virusRight", "Virus (Left)")
{
function = delegate { var e = eventCaller.currentEntity; SickBeats.instance.PresenceVirus(e.beat, (int)SickBeats.Direction.Left, e["type"]); },
parameters = new List<Param>()
{
new Param("type", SickBeats.VirusType.Blue, "Type", "Determine virus type"),
},
defaultLength = 6f,
},
new GameAction("virusDown", "Virus (Down)")
{
function = delegate { var e = eventCaller.currentEntity; SickBeats.instance.PresenceVirus(e.beat, (int)SickBeats.Direction.Down, e["type"]); },
parameters = new List<Param>()
{
new Param("type", SickBeats.VirusType.Blue, "Type", "Determine virus type"),
},
defaultLength = 6f,
defaultLength = 2f,
},
new GameAction("appear", "Appear")
{
function = delegate {var e = eventCaller.currentEntity; SickBeats.instance.VirusAppearMnl(e.beat, e["direction"], e["type"]); },
parameters = new List<Param>()
{
new Param("direction", SickBeats.Direction.Right, "Direction", "Determine which direction the virus will spawn from"),
new Param("type", SickBeats.VirusType.Blue, "Type", "Determine virus type"),
new Param("direction", SickBeats.Direction.Right, "Direction", "Determine which direction the virus will spawn from."),
new Param("type", SickBeats.VirusType.Blue, "Type", "Determine virus type."),
},
defaultLength = 2f,
},
@ -81,20 +55,20 @@ namespace HeavenStudio.Games.Loaders
e["direction"], e["type"], new double[]{e["param1"], e["param2"], e["param3"]}); },
parameters = new List<Param>()
{
new Param("direction", SickBeats.Direction.Up, "Direction", "Determine which direction the virus will spawn from"),
new Param("type", SickBeats.VirusType.Blue, "Type", "Determine virus type"),
new Param("param1", new EntityTypes.Float(0, 1, 0), "1"),
new Param("param2", new EntityTypes.Float(0, 1, 0.125f), "2"),
new Param("param3", new EntityTypes.Float(0, 1, 0.25f), "3"),
new Param("direction", SickBeats.Direction.Up, "Direction", "Determine which direction the virus will spawn from."),
new Param("type", SickBeats.VirusType.Blue, "Type", "Determine virus type."),
new Param("param1", new EntityTypes.Float(0, 1, 0), "Right Beat", "Decide the right Dash beat."),
new Param("param2", new EntityTypes.Float(0, 1, 0.125f), "Up Beat", "Decide the up Dash beat."),
new Param("param3", new EntityTypes.Float(0, 1, 0.25f), "Left Beat", "Decide the left Dash beat."),
},
defaultLength = 1f,
},
new GameAction("come", "Come")
new GameAction("summon", "Summon")
{
function = delegate {var e = eventCaller.currentEntity; SickBeats.instance.VirusComeMnl(e.beat, e["type"]); },
function = delegate {var e = eventCaller.currentEntity; SickBeats.instance.VirusSummonMnl(e.beat, e["type"]); },
parameters = new List<Param>()
{
new Param("type", SickBeats.VirusType.Blue, "Type", "Determine virus type"),
new Param("type", SickBeats.VirusType.Blue, "Type", "Determine virus type."),
},
defaultLength = 2f,
},
@ -156,8 +130,11 @@ namespace HeavenStudio.Games
[SerializeField] DashPatternItem[] DashPatterns;
[System.NonSerialized] public bool[] isForkPop = {true, true, true, true};
[System.NonSerialized] public bool[] isMiss = {false, false, false, false};
[System.NonSerialized] public bool[] isPrepare = {false, false, false, false};
[System.NonSerialized] public bool orgAlive = true;
[System.NonSerialized] public bool docShock = false;
[System.NonSerialized] public double docShockBeat = Double.MinValue;
public enum Direction
{
@ -189,11 +166,7 @@ namespace HeavenStudio.Games
{
return PlayerInput.GetBatonDown(InputController.ActionsBaton.East, out dt);
}
protected static bool IA_TouchRight(out double dt)
{
return PlayerInput.GetTouchDown(InputController.ActionsTouch.Right, out dt)
&& (instance.IsExpectingInputNow(InputAction_Right) || instance.IsExpectingInputNow(InputAction_Left));
}
protected static bool IA_PadUp(out double dt)
{
return PlayerInput.GetPadDown(InputController.ActionsPad.Up, out dt);
@ -202,11 +175,7 @@ namespace HeavenStudio.Games
{
return PlayerInput.GetBatonDown(InputController.ActionsBaton.North, out dt);
}
protected static bool IA_TouchUp(out double dt)
{
return PlayerInput.GetTouchDown(InputController.ActionsTouch.Tap, out dt)
&& instance.IsExpectingInputNow(InputAction_Up);
}
protected static bool IA_PadLeft(out double dt)
{
return PlayerInput.GetPadDown(InputController.ActionsPad.Left, out dt);
@ -215,11 +184,7 @@ namespace HeavenStudio.Games
{
return PlayerInput.GetBatonDown(InputController.ActionsBaton.West, out dt);
}
protected static bool IA_TouchLeft(out double dt)
{
return PlayerInput.GetTouchDown(InputController.ActionsTouch.Left, out dt)
&& (instance.IsExpectingInputNow(InputAction_Right) || instance.IsExpectingInputNow(InputAction_Left));
}
protected static bool IA_PadDown(out double dt)
{
return PlayerInput.GetPadDown(InputController.ActionsPad.Down, out dt);
@ -228,24 +193,32 @@ namespace HeavenStudio.Games
{
return PlayerInput.GetBatonDown(InputController.ActionsBaton.South, out dt);
}
protected static bool IA_TouchDown(out double dt)
{
return PlayerInput.GetTouchDown(InputController.ActionsTouch.Tap, out dt)
&& instance.IsExpectingInputNow(InputAction_Down);
}
public static PlayerInput.InputAction InputAction_Right =
new("AgbSickBeatsRight", new int[] { IA_RightPress, IA_RightPress, IA_RightPress },
IA_PadRight, IA_TouchRight, IA_BatonRight);
IA_PadRight, IA_TouchFlick, IA_BatonRight);
public static PlayerInput.InputAction InputAction_Up =
new("AgbSickBeatsUp", new int[] { IA_UpPress, IA_UpPress, IA_UpPress },
IA_PadUp, IA_TouchUp, IA_BatonUp);
IA_PadUp, IA_TouchFlick, IA_BatonUp);
public static PlayerInput.InputAction InputAction_Left =
new("AgbSickBeatsLeft", new int[] { IA_LeftPress, IA_LeftPress, IA_LeftPress },
IA_PadLeft, IA_TouchLeft, IA_BatonLeft);
IA_PadLeft, IA_TouchFlick, IA_BatonLeft);
public static PlayerInput.InputAction InputAction_Down =
new("AgbSickBeatsDown", new int[] { IA_DownPress, IA_DownPress, IA_DownPress },
IA_PadDown, IA_TouchDown, IA_BatonDown);
IA_PadDown, IA_TouchFlick, IA_BatonDown);
public PlayerActionEvent ScheduleMissableInput(double startBeat,
double timer,
PlayerInput.InputAction inputAction,
PlayerActionEvent.ActionEventCallbackState OnHit,
PlayerActionEvent.ActionEventCallback OnMiss,
PlayerActionEvent.ActionEventCallback OnBlank,
PlayerActionEvent.ActionEventHittableQuery HittableQuery = null)
{
PlayerActionEvent evt = ScheduleInput(startBeat, timer, inputAction, OnHit, OnMiss, OnBlank, HittableQuery);
evt.missable = true;
return evt;
}
// Start is called before the first frame update
void Awake()
@ -257,7 +230,21 @@ namespace HeavenStudio.Games
public override void OnBeatPulse(double beat)
{
if (BeatIsInBopRegion(beat)) Bop();
if (BeatIsInBopRegion(beat)) Bop(beat);
}
[NonSerialized] public double gameEndBeat = double.MaxValue;
public override void OnGameSwitch(double beat)
{
var entities = GameManager.instance.Beatmap.Entities;
// find out when the next game switch (or remix end) happens
RiqEntity firstEnd = entities.Find(c => (c.datamodel.StartsWith("gameManager/switchGame") || c.datamodel.Equals("gameManager/end")) && c.beat > beat);
gameEndBeat = firstEnd?.beat ?? double.MaxValue;
}
public override void OnPlay(double beat)
{
OnGameSwitch(beat);
}
void Update()
@ -265,22 +252,43 @@ namespace HeavenStudio.Games
var cond = Conductor.instance;
if (!cond.isPlaying || cond.isPaused) return;
if (PlayerInput.GetIsAction(InputAction_Right) && !IsExpectingInputNow(InputAction_Right))
if (PlayerInput.PlayerHasControl() && PlayerInput.CurrentControlStyle is InputSystem.InputController.ControlStyles.Touch)
{
if (isForkPop[0]) OutFork(0);
if (PlayerInput.GetIsAction(InputAction_BasicPress))
{
keyAnim.Play("keep");
}
if (PlayerInput.GetIsAction(InputAction_BasicRelease))
{
keyAnim.Play("up");
}
if (PlayerInput.GetIsAction(InputAction_FlickPress) && !IsExpectingInputNow(InputAction_FlickPress))
{
var rand_dir = ChooseDirection(isMiss, isPrepare, isForkPop);
if (isForkPop[rand_dir]) OutFork(rand_dir);
}
}
if (PlayerInput.GetIsAction(InputAction_Up) && !IsExpectingInputNow(InputAction_Up))
else
{
if (isForkPop[1]) OutFork(1);
}
if (PlayerInput.GetIsAction(InputAction_Left) && !IsExpectingInputNow(InputAction_Left))
{
if (isForkPop[2]) OutFork(2);
}
if (PlayerInput.GetIsAction(InputAction_Down) && !IsExpectingInputNow(InputAction_Down))
{
if (isForkPop[3]) OutFork(3);
if (PlayerInput.GetIsAction(InputAction_Right) && !IsExpectingInputNow(InputAction_Right))
{
if (isForkPop[(int)Direction.Right]) OutFork((int)Direction.Right);
}
if (PlayerInput.GetIsAction(InputAction_Up) && !IsExpectingInputNow(InputAction_Up))
{
if (isForkPop[(int)Direction.Up]) OutFork((int)Direction.Up);
}
if (PlayerInput.GetIsAction(InputAction_Left) && !IsExpectingInputNow(InputAction_Left))
{
if (isForkPop[(int)Direction.Left]) OutFork((int)Direction.Left);
}
if (PlayerInput.GetIsAction(InputAction_Down) && !IsExpectingInputNow(InputAction_Down))
{
if (isForkPop[(int)Direction.Down]) OutFork((int)Direction.Down);
}
}
}
private void OutFork(int dir)
@ -290,7 +298,7 @@ namespace HeavenStudio.Games
var actions = new List<BeatAction.Action>();
keyAnim.Play("push");
forkAnims[dir].Play("out");
SoundByte.PlayOneShotGame("sickBeats/1", pitch: UnityEngine.Random.Range(2.75f, 3.25f));
SoundByte.PlayOneShotGame("sickBeats/fork"+UnityEngine.Random.Range(0, 3).ToString());
BeatAction.New(instance, new() {new BeatAction.Action(currentBeat + RefillBeat, delegate {RepopFork(dir);})});
isForkPop[dir] = false;
@ -308,15 +316,15 @@ namespace HeavenStudio.Games
{
for (int i = 0; i < length; i++)
{
BeatAction.New(instance, new() {new BeatAction.Action(beat + i, delegate {Bop();}) });
BeatAction.New(instance, new() {new BeatAction.Action(beat + i, delegate {Bop(beat);}) });
}
}
}
public void Bop()
public void Bop(double beat)
{
radioAnim.DoScaledAnimationAsync("bop", 0.5f);
if (!docShock) doctorAnim.DoScaledAnimationAsync("bop", 0.5f);
if (beat < docShockBeat || beat > docShockBeat + 2) doctorAnim.DoScaledAnimationAsync("bop", 0.5f);
if (orgAlive) orgAnim.DoScaledAnimationAsync("bop", 0.5f);
}
@ -332,14 +340,14 @@ namespace HeavenStudio.Games
return newVirus;
}
public void PresenceVirus(double beat, int dir, int type)
public void MoveVirus(double beat, int dir, int type)
{
var newVirus = SpawnVirus(beat, -1, type);
var actions = new List<BeatAction.Action>();
actions.Add(new BeatAction.Action(beat, delegate {
newVirus.Come();
newVirus.Summon();
newVirus.position++;
}));
@ -392,14 +400,14 @@ namespace HeavenStudio.Games
BeatAction.New(instance, actions);
}
public void VirusComeMnl(double beat, int type)
public void VirusSummonMnl(double beat, int type)
{
var newVirus = SpawnVirus(beat, -1, type);
var actions = new List<BeatAction.Action>();
actions.Add(new BeatAction.Action(beat, delegate {
newVirus.Come();
newVirus.Summon();
newVirus.position++;
}));
actions.Add(new BeatAction.Action(beat + 2, delegate {Destroy(newVirus.gameObject);}));
@ -424,5 +432,37 @@ namespace HeavenStudio.Games
RecolorMats[i].SetColor("_ColorDelta", color3);
}
}
public static int ChooseDirection(bool[] misses, bool[] preparing, bool[] isForkPop)
{
var missedDirections = Enumerable.Range(0, 4)
.Where(i => misses[i] && isForkPop[i])
.ToList();
if (missedDirections.Count > 0)
{
int index = UnityEngine.Random.Range(0, missedDirections.Count);
return missedDirections[index];
}
var preparingDirections = Enumerable.Range(0, 4)
.Where(i => preparing[i] && isForkPop[i])
.ToList();
if (preparingDirections.Count > 0)
{
int index = UnityEngine.Random.Range(0, preparingDirections.Count);
return preparingDirections[index];
}
var remainingDirections = Enumerable.Range(0, 4)
.Where(i => isForkPop[i])
.ToList();
if (remainingDirections.Count > 0)
{
int index = UnityEngine.Random.Range(0, remainingDirections.Count);
return remainingDirections[index];
}
return UnityEngine.Random.Range(0, 4);
}
}
}

122
Assets/Scripts/Games/SickBeats/Virus.cs
View File

@ -19,6 +19,8 @@ namespace HeavenStudio.Games.Scripts_SickBeats
public int position;
public int life = 1;
bool isJust = false; // not fundamental solution
private SickBeats game;
public void Init()
@ -29,33 +31,58 @@ namespace HeavenStudio.Games.Scripts_SickBeats
public void Appear()
{
var InputAction = position switch {
0 => SickBeats.InputAction_Right,
1 => SickBeats.InputAction_Up,
2 => SickBeats.InputAction_Left,
3 => SickBeats.InputAction_Down,
};
if (startBeat >= game.gameEndBeat) return;
MultiSound.Play(new MultiSound.Sound[]
{
new MultiSound.Sound("sickBeats/appear", startBeat, pitch: UnityEngine.Random.Range(0.9f, 1.1f)),
new MultiSound.Sound("sickBeats/appear"+UnityEngine.Random.Range(0, 2).ToString(), startBeat),
});
BeatAction.New(game, new() {new BeatAction.Action(startBeat, delegate {
VirusAnim("appear");
})});
game.ScheduleInput(startBeat, 1, InputAction, Just, Miss, Empty, CanJust);
isJust = false;
PlayerInput.InputAction InputAction;
if (PlayerInput.PlayerHasControl() && PlayerInput.CurrentControlStyle is InputSystem.InputController.ControlStyles.Touch)
{
InputAction = SickBeats.InputAction_FlickPress;
}
else
{
InputAction = position switch {
0 => SickBeats.InputAction_Right,
1 => SickBeats.InputAction_Up,
2 => SickBeats.InputAction_Left,
3 => SickBeats.InputAction_Down,
};
}
// if (GameManager.instance.autoplay)
// {
// game.ScheduleAutoplayInput(startBeat, 1, InputAction, Just, Miss, Empty);
// }
// else
// {
// game.ScheduleUserInput(startBeat, 1, InputAction, Just, Miss, Empty, CanJust);
// }
game.ScheduleMissableInput(startBeat, 1, InputAction, Just, Miss, Empty, CanJust);
var dir = position;
BeatAction.New(game, new() {
new BeatAction.Action(startBeat, delegate { game.isPrepare[dir] = true;}),
new BeatAction.Action((startBeat+1.5f), delegate { game.isPrepare[dir] = false;}),
});
}
public void Dash()
{
SoundByte.PlayOneShotGame("sickBeats/whoosh");
SoundByte.PlayOneShotGame("sickBeats/dash");
VirusAnim("dash");
}
public void Come()
public void Summon()
{
VirusAnim("come");
VirusAnim("summon");
}
public void Move()
@ -75,36 +102,58 @@ namespace HeavenStudio.Games.Scripts_SickBeats
public void Kill()
{
game.ScoreMiss();
MultiSound.Play(new MultiSound.Sound[]
{
new MultiSound.Sound("sickBeats/virusIn", startBeat + 2),
new MultiSound.Sound("sickBeats/miss", startBeat + 4),
new MultiSound.Sound("sickBeats/fadeout", startBeat + 5),
});
BeatAction.New(game, new() {
new BeatAction.Action((startBeat+1) + game.RefillBeat, delegate {
new BeatAction.Action(startBeat + 2, delegate {
virusAnim.DoScaledAnimationAsync("laugh", 0.5f);
virusAnim.DoScaledAnimationAsync("enter", 0.5f);
}),
new BeatAction.Action((startBeat+3) + game.RefillBeat, delegate {
new BeatAction.Action(startBeat + 4, delegate {
virusAnim.DoScaledAnimationAsync("hide", 0.5f);
game.orgAnim.DoScaledAnimationAsync("damage", 0.5f);
game.orgAlive = false;
}),
new BeatAction.Action((startBeat+4) + game.RefillBeat, delegate {
new BeatAction.Action(startBeat + 5, delegate {
game.orgAnim.DoScaledAnimationAsync("vanish", 0.5f);
}),
new BeatAction.Action((startBeat+5) + game.RefillBeat, delegate {
new BeatAction.Action(startBeat + 6, delegate {
virusAnim.DoScaledAnimationAsync("laugh", 0.5f);
game.docShock = true;
game.doctorAnim.DoScaledAnimationAsync("shock0", 0.5f);
}),
new BeatAction.Action((startBeat+6) + game.RefillBeat, delegate {
new BeatAction.Action(startBeat + 7, delegate {
game.orgAnim.DoScaledAnimationAsync("idleAdd", 0.5f);
game.orgAnim.DoScaledAnimationAsync("appear", 0.5f);
game.orgAlive = true;
Destroy(gameObject);
game.doctorAnim.DoScaledAnimationAsync("shock1", 0.5f);
}),
new BeatAction.Action((startBeat+8) + game.RefillBeat, delegate {
game.docShock = false;
game.doctorAnim.DoScaledAnimationAsync("idle", 0.5f);
}),
});
Debug.Log(startBeat);
Debug.Log(game.docShockBeat);
if (startBeat + 6 >= game.docShockBeat + 3)
{
game.docShockBeat = startBeat + 6;
BeatAction.New(game, new() {
new BeatAction.Action(startBeat + 6, delegate {
game.docShock = true;
game.doctorAnim.DoScaledAnimationAsync("shock0", 0.5f);
}),
new BeatAction.Action(startBeat + 7, delegate {
game.doctorAnim.DoScaledAnimationAsync("shock1", 0.5f);
}),
new BeatAction.Action(startBeat + 9, delegate {
game.docShock = false;
game.doctorAnim.DoScaledAnimationAsync("idle", 0.5f);
}),
});
}
}
private void Just(PlayerActionEvent caller, float state)
@ -114,23 +163,25 @@ namespace HeavenStudio.Games.Scripts_SickBeats
var dir = position;
BeatAction.New(game, new() {new BeatAction.Action((startBeat+1) + game.RefillBeat, delegate { game.RepopFork(dir);})});
game.isForkPop[dir] = false;
isJust = true;
if (life < 0)
{
if (state >= 1f)
{
SoundByte.PlayOneShotGame("sickBeats/bad");
VirusAnim("stabLate");
KeyAnim("stabLate");
}
else if (state <= -1f)
{
SoundByte.PlayOneShotGame("sickBeats/bad");
VirusAnim("stabFast");
KeyAnim("stabFast");
}
else
{
SoundByte.PlayOneShotGame("sickBeats/stab");
SoundByte.PlayOneShotGame("sickBeats/hit");
VirusAnim("stab");
KeyAnim("stab");
@ -151,6 +202,12 @@ namespace HeavenStudio.Games.Scripts_SickBeats
private void Miss(PlayerActionEvent caller)
{
var dir = position;
if (dir >= 0 && dir <= 3)
{
game.isMiss[dir] = true;
BeatAction.New(game, new() {new BeatAction.Action((startBeat+1.5f), delegate { game.isMiss[dir] = false;})});
}
Dash();
Move();
}
@ -159,7 +216,7 @@ namespace HeavenStudio.Games.Scripts_SickBeats
private bool CanJust() {
if (position < 0 || position > 3) return false;
return game.isForkPop[position];
return game.isForkPop[position] || isJust;
}
void VirusAnim(string animation)
@ -186,13 +243,10 @@ namespace HeavenStudio.Games.Scripts_SickBeats
void ChangeColor()
{
renderers[0].material = game.RecolorMats[life];
renderers[1].material = game.RecolorMats[life];
Color newColor = game.color[life];
renderers[2].color = new Color(newColor.r, newColor.g, newColor.b, renderers[2].color.a);
foreach (var renderer in renderers)
{
renderer.material = game.RecolorMats[life];
}
}
}
}

20
Assets/Scripts/USG.g/LoadMinigames.Minigames.MinigameLoaderGenerator.g.cs
View File

@ -102,16 +102,6 @@ namespace HeavenStudio
{
Debug.LogWarning("Game loader RvlBookLoader failed!");
}
game = NtrFreezeFrameLoader.AddGame(eventCaller);
if (game != null)
{
eventCaller.minigames.Add(game.name, game);
}
else
{
Debug.LogWarning("Game loader NtrCameraManLoader failed!");
}
game = AgbClapLoader.AddGame(eventCaller);
if (game != null)
@ -243,6 +233,16 @@ namespace HeavenStudio
Debug.LogWarning("Game loader RvlForkLoader failed!");
}
game = NtrFreezeFrameLoader.AddGame(eventCaller);
if (game != null)
{
eventCaller.minigames.Add(game.name, game);
}
else
{
Debug.LogWarning("Game loader NtrFreezeFrameLoader failed!");
}
game = NtrGleeClubLoader.AddGame(eventCaller);
if (game != null)
{