428 lines
17 KiB
C#
428 lines
17 KiB
C#
using System;
|
|
using System.Linq;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
|
|
using HeavenStudio.Util;
|
|
using HeavenStudio.InputSystem;
|
|
|
|
using Jukebox;
|
|
|
|
namespace HeavenStudio.Games.Loaders
|
|
{
|
|
using static Minigames;
|
|
|
|
public static class AgbSickBeats
|
|
{
|
|
public static Minigame AddGame(EventCaller eventCaller)
|
|
{
|
|
return new Minigame("sickBeats", "Sick Beats", "ffffff", false, false, new List<GameAction>()
|
|
{
|
|
new GameAction("bop", "Bop")
|
|
{
|
|
function = delegate { var e = eventCaller.currentEntity; SickBeats.instance.ToggleBop(e.beat, e.length, e["toggle2"], e["toggle"]); },
|
|
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 GameAction("virusLeft", "Virus (Right)")
|
|
{
|
|
function = delegate { var e = eventCaller.currentEntity; SickBeats.instance.PresenceVirus(e.beat, (int)SickBeats.Direction.Right, e["type"]); },
|
|
parameters = new List<Param>()
|
|
{
|
|
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,
|
|
},
|
|
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"),
|
|
},
|
|
defaultLength = 2f,
|
|
},
|
|
new GameAction("dash", "Dash")
|
|
{
|
|
function = delegate {var e = eventCaller.currentEntity; SickBeats.instance.VirusDashMnl(e.beat,
|
|
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"),
|
|
},
|
|
defaultLength = 1f,
|
|
},
|
|
new GameAction("come", "Come")
|
|
{
|
|
function = delegate {var e = eventCaller.currentEntity; SickBeats.instance.VirusComeMnl(e.beat, e["type"]); },
|
|
parameters = new List<Param>()
|
|
{
|
|
new Param("type", SickBeats.VirusType.Blue, "Type", "Determine virus type"),
|
|
},
|
|
defaultLength = 2f,
|
|
},
|
|
new GameAction("virusColor", "Change Virus Color")
|
|
{
|
|
function = delegate {
|
|
var e = eventCaller.currentEntity;
|
|
SickBeats.instance.UpdateMaterialColor(e["colorVirus1"], e["colorVirus2"], e["colorVirus3"], e["colorVirus4"]);
|
|
},
|
|
defaultLength = 0.5f,
|
|
parameters = new List<Param>()
|
|
{
|
|
new Param("colorVirus1", new Color(0f, 1f, 1f), "1st Color", "Set the color of the first virus."),
|
|
new Param("colorVirus2", new Color(1f, 0.25f, 0.75f), "2nd Color", "Set the color of the second virus."),
|
|
new Param("colorVirus3", new Color(0f, 0f, 0f), "3rd Color", "Set the color of the third virus."),
|
|
new Param("colorVirus4", new Color(1f, 1f, 1f), "4th Color", "Set the color of the fourth virus."),
|
|
}
|
|
},
|
|
},
|
|
new List<string>() { "agb", "normal" }, "agbSickBeats", "en", new List<string>() { }
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
namespace HeavenStudio.Games
|
|
{
|
|
using Scripts_SickBeats;
|
|
|
|
public class SickBeats : Minigame
|
|
{
|
|
[Header("References")]
|
|
public Animator keyAnim;
|
|
public Animator[] forkAnims;
|
|
public Animator doctorAnim;
|
|
public Animator radioAnim;
|
|
public Animator orgAnim;
|
|
public GameObject baseVirus;
|
|
public Transform virusHolder;
|
|
|
|
[Header("Colorable")]
|
|
public Material[] RecolorMats;
|
|
public Color[] color = {new Color(0f, 1f, 1f), new Color(1f, 0.25f, 0.75f),
|
|
new Color(0f, 0f, 0f), new Color(1f, 1f, 1f)};
|
|
|
|
[Header("Variables")]
|
|
[SerializeField] double _refillBeat;
|
|
public double RefillBeat
|
|
{
|
|
get => _refillBeat;
|
|
private set => _refillBeat = value;
|
|
}
|
|
|
|
[Serializable]
|
|
public struct DashPatternItem
|
|
{
|
|
public double[] beat;
|
|
}
|
|
[SerializeField] DashPatternItem[] DashPatterns;
|
|
|
|
[System.NonSerialized] public bool[] isForkPop = {true, true, true, true};
|
|
[System.NonSerialized] public bool orgAlive = true;
|
|
[System.NonSerialized] public bool docShock = false;
|
|
|
|
public enum Direction
|
|
{
|
|
Right,
|
|
Up,
|
|
Left,
|
|
Down,
|
|
}
|
|
public enum VirusType
|
|
{
|
|
Blue,
|
|
Pink,
|
|
Black,
|
|
Custom,
|
|
}
|
|
|
|
public static SickBeats instance;
|
|
|
|
const int IA_RightPress = IAMAXCAT;
|
|
const int IA_UpPress = IAMAXCAT + 1;
|
|
const int IA_LeftPress = IAMAXCAT + 2;
|
|
const int IA_DownPress = IAMAXCAT + 3;
|
|
|
|
protected static bool IA_PadRight(out double dt)
|
|
{
|
|
return PlayerInput.GetPadDown(InputController.ActionsPad.Right, out dt);
|
|
}
|
|
protected static bool IA_BatonRight(out double dt)
|
|
{
|
|
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);
|
|
}
|
|
protected static bool IA_BatonUp(out double dt)
|
|
{
|
|
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);
|
|
}
|
|
protected static bool IA_BatonLeft(out double dt)
|
|
{
|
|
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);
|
|
}
|
|
protected static bool IA_BatonDown(out double dt)
|
|
{
|
|
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);
|
|
public static PlayerInput.InputAction InputAction_Up =
|
|
new("AgbSickBeatsUp", new int[] { IA_UpPress, IA_UpPress, IA_UpPress },
|
|
IA_PadUp, IA_TouchUp, IA_BatonUp);
|
|
public static PlayerInput.InputAction InputAction_Left =
|
|
new("AgbSickBeatsLeft", new int[] { IA_LeftPress, IA_LeftPress, IA_LeftPress },
|
|
IA_PadLeft, IA_TouchLeft, IA_BatonLeft);
|
|
public static PlayerInput.InputAction InputAction_Down =
|
|
new("AgbSickBeatsDown", new int[] { IA_DownPress, IA_DownPress, IA_DownPress },
|
|
IA_PadDown, IA_TouchDown, IA_BatonDown);
|
|
|
|
// Start is called before the first frame update
|
|
void Awake()
|
|
{
|
|
instance = this;
|
|
SetupBopRegion("sickBeats", "bop", "toggle");
|
|
UpdateMaterialColor(color[0], color[1], color[2], color[3]);
|
|
}
|
|
|
|
public override void OnBeatPulse(double beat)
|
|
{
|
|
if (BeatIsInBopRegion(beat)) Bop();
|
|
}
|
|
|
|
void Update()
|
|
{
|
|
var cond = Conductor.instance;
|
|
if (!cond.isPlaying || cond.isPaused) return;
|
|
|
|
if (PlayerInput.GetIsAction(InputAction_Right) && !IsExpectingInputNow(InputAction_Right))
|
|
{
|
|
if (isForkPop[0]) OutFork(0);
|
|
}
|
|
if (PlayerInput.GetIsAction(InputAction_Up) && !IsExpectingInputNow(InputAction_Up))
|
|
{
|
|
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);
|
|
}
|
|
}
|
|
|
|
private void OutFork(int dir)
|
|
{
|
|
var currentBeat = Conductor.instance.songPositionInBeatsAsDouble;
|
|
|
|
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));
|
|
BeatAction.New(instance, new() {new BeatAction.Action(currentBeat + RefillBeat, delegate {RepopFork(dir);})});
|
|
|
|
isForkPop[dir] = false;
|
|
}
|
|
public void RepopFork(int dir)
|
|
{
|
|
forkAnims[dir].Play("repop");
|
|
|
|
isForkPop[dir] = true;
|
|
}
|
|
|
|
public void ToggleBop(double beat, float length, bool bopOrNah, bool autoBop)
|
|
{
|
|
if (bopOrNah)
|
|
{
|
|
for (int i = 0; i < length; i++)
|
|
{
|
|
BeatAction.New(instance, new() {new BeatAction.Action(beat + i, delegate {Bop();}) });
|
|
}
|
|
}
|
|
}
|
|
|
|
public void Bop()
|
|
{
|
|
radioAnim.DoScaledAnimationAsync("bop", 0.5f);
|
|
if (!docShock) doctorAnim.DoScaledAnimationAsync("bop", 0.5f);
|
|
if (orgAlive) orgAnim.DoScaledAnimationAsync("bop", 0.5f);
|
|
}
|
|
|
|
public Virus SpawnVirus(double beat, int dir, int type)
|
|
{
|
|
var newVirus = Instantiate(baseVirus, virusHolder).GetComponent<Virus>();
|
|
newVirus.startBeat = beat;
|
|
newVirus.position = dir;
|
|
newVirus.life = type;
|
|
newVirus.gameObject.SetActive(true);
|
|
newVirus.Init();
|
|
|
|
return newVirus;
|
|
}
|
|
|
|
public void PresenceVirus(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.position++;
|
|
}));
|
|
|
|
switch (dir)
|
|
{
|
|
case (int)Direction.Right:
|
|
newVirus.startBeat = beat + 2;
|
|
actions.Add(new BeatAction.Action(beat + 2, delegate {newVirus.Appear();}));
|
|
break;
|
|
case (int)Direction.Up:
|
|
case (int)Direction.Left:
|
|
case (int)Direction.Down:
|
|
for(int i = 0; i < dir; i++)
|
|
{
|
|
actions.Add(new BeatAction.Action(beat + DashPatterns[dir-1].beat[i], delegate {
|
|
newVirus.Dash();
|
|
newVirus.position++;
|
|
}));
|
|
}
|
|
newVirus.startBeat = beat + 4;
|
|
actions.Add(new BeatAction.Action(beat + 4, delegate {newVirus.Appear();}));
|
|
break;
|
|
}
|
|
|
|
BeatAction.New(instance, actions);
|
|
|
|
}
|
|
|
|
public void VirusAppearMnl(double beat, int dir, int type)
|
|
{
|
|
var newVirus = SpawnVirus(beat, dir, type);
|
|
newVirus.Appear();
|
|
}
|
|
|
|
public void VirusDashMnl(double beat, int dir, int type, double[] dashbeats)
|
|
{
|
|
if (dir<1) dir = 1;
|
|
var newVirus = SpawnVirus(beat, 0, type);
|
|
|
|
var actions = new List<BeatAction.Action>();
|
|
|
|
for(int i = 0; i < dir; i++)
|
|
{
|
|
actions.Add(new BeatAction.Action(beat + dashbeats[i], delegate {
|
|
newVirus.Dash();
|
|
newVirus.position++;
|
|
}));
|
|
}
|
|
actions.Add(new BeatAction.Action(beat + 2, delegate {Destroy(newVirus.gameObject);}));
|
|
BeatAction.New(instance, actions);
|
|
}
|
|
|
|
public void VirusComeMnl(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.position++;
|
|
}));
|
|
actions.Add(new BeatAction.Action(beat + 2, delegate {Destroy(newVirus.gameObject);}));
|
|
BeatAction.New(instance, actions);
|
|
}
|
|
|
|
|
|
|
|
public void UpdateMaterialColor(Color virus1, Color virus2, Color virus3, Color virus4)
|
|
{
|
|
color[0] = virus1; color[1] = virus2; color[2] = virus3; color[3] = virus4;
|
|
|
|
Recolor(0, new Color(0.75f, 0f, 0f), virus2, virus1);
|
|
Recolor(1, new Color(0.75f, 0f, 0f), virus3, virus2);
|
|
Recolor(2, new Color(0.75f, 0f, 0f), virus4, virus3);
|
|
Recolor(3, new Color(0.75f, 0f, 0f), virus4, virus4);
|
|
|
|
void Recolor(int i, Color color1, Color color2, Color color3)
|
|
{
|
|
RecolorMats[i].SetColor("_ColorAlpha", color1);
|
|
RecolorMats[i].SetColor("_ColorBravo", color2);
|
|
RecolorMats[i].SetColor("_ColorDelta", color3);
|
|
}
|
|
}
|
|
}
|
|
} |