mirror of
https://github.com/RHeavenStudioPlus/HeavenStudioPlus.git
synced 2024-11-14 05:35:08 +00:00
526 lines
22 KiB
C#
526 lines
22 KiB
C#
//notes:
|
|
// BEFORE NEW PROPS
|
|
// - minenice will also use this to test out randomly named parameters so coding has to rest until the new props update [DONE]
|
|
// - see fan club for separate prefabs (cadets) [DONE]
|
|
// - temporarily take sounds from rhre, wait until someone records the full code, including misses, or record it myself (unlikely) [IN PROGRESS]
|
|
// AFTER NEW PROPS
|
|
// - testmod marching orders using speed
|
|
// - see space soccer, mr upbeat, tunnel for keep-the-beat codes
|
|
// - figure how to do custom bg changes when the upscaled textures are finished (see karate man, launch party once it releases)
|
|
// - will use a textbox without going through the visual options but i wonder how..?? (see first contact if ever textboxes are implemented in said minigame)
|
|
// AFTER FEATURE COMPLETION
|
|
// - delete all notes once the minigame is considered feature-complete
|
|
|
|
using HeavenStudio.Util;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using UnityEditor;
|
|
using UnityEngine;
|
|
|
|
namespace HeavenStudio.Games.Loaders
|
|
{
|
|
using static Minigames;
|
|
public static class AgbMarcherLoader
|
|
{
|
|
public static Minigame AddGame(EventCaller eventCaller) {
|
|
return new Minigame("marchingOrders", "Marching Orders", "ffb108", false, false, new List<GameAction>()
|
|
{
|
|
new GameAction("bop", "Bop")
|
|
{
|
|
function = delegate { var e = eventCaller.currentEntity; MarchingOrders.instance.BopAction(e.beat, e.length, e["bop"], e["autoBop"]); },
|
|
defaultLength = 1f,
|
|
resizable = true,
|
|
parameters = new List<Param>()
|
|
{
|
|
new Param("bop", true, "Bop", "Should the cadets bop?"),
|
|
new Param("autoBop", false, "Bop (Auto)", "Should the cadets auto bop?")
|
|
}
|
|
},
|
|
|
|
new GameAction("marching", "Cadets March")
|
|
{
|
|
preFunction = delegate {
|
|
var e = eventCaller.currentEntity;
|
|
MarchingOrders.PreMarch(e.beat, e.length);
|
|
},
|
|
defaultLength = 4f,
|
|
resizable = true,
|
|
},
|
|
|
|
new GameAction("attention", "Attention...")
|
|
{
|
|
function = delegate { var e = eventCaller.currentEntity; MarchingOrders.instance.SargeAttention(e.beat); },
|
|
defaultLength = 2f,
|
|
preFunction = delegate { var e = eventCaller.currentEntity; MarchingOrders.AttentionSound(e.beat);}
|
|
},
|
|
|
|
new GameAction("march", "March!")
|
|
{
|
|
function = delegate { var e = eventCaller.currentEntity; MarchingOrders.instance.SargeMarch(e.beat, e["toggle"]); },
|
|
defaultLength = 2f,
|
|
parameters = new List<Param>
|
|
{
|
|
new Param("toggle", false, "Disable Voice", "Disable the Drill Sergeant's call")
|
|
},
|
|
inactiveFunction = delegate { var e = eventCaller.currentEntity; MarchingOrders.MarchSound(e.beat, e["toggle"]);}
|
|
},
|
|
|
|
new GameAction("halt", "Halt!")
|
|
{
|
|
function = delegate { var e = eventCaller.currentEntity; MarchingOrders.instance.SargeHalt(e.beat); },
|
|
defaultLength = 2f,
|
|
inactiveFunction = delegate { var e = eventCaller.currentEntity; MarchingOrders.HaltSound(e.beat);}
|
|
},
|
|
|
|
new GameAction("face turn", "Direction to Turn")
|
|
{
|
|
function = delegate { var e = eventCaller.currentEntity; MarchingOrders.instance.SargeFaceTurn(e.beat, e["type"], e["type2"], false); },
|
|
defaultLength = 4f,
|
|
parameters = new List<Param>()
|
|
{
|
|
new Param("type", MarchingOrders.DirectionFaceTurn.Right, "Direction", "The direction the sergeant wants the cadets to face"),
|
|
new Param("type2", MarchingOrders.FaceTurnLength.Normal, "Length", "The duration of the turning event"),
|
|
//new Param("toggle", false, "Point", "Do the pointing animation instead of just the head turn")
|
|
}
|
|
},
|
|
|
|
/*new GameAction("background", "Set the Background") colors aren't implemented yet
|
|
{
|
|
function = delegate { var e = eventCaller.currentEntity; MarchingOrders.instance.BackgroundColorSet(e.beat, e["type"], e["type2"], e["colorDefault"], e["colorPipe"], e["colorFloor"], e["colorFill"]); },
|
|
defaultLength = 0.5f,
|
|
parameters = new List<Param>()
|
|
{
|
|
new Param("type", MarchingOrders.BackgroundColor.Blue, "Color", "The game Background Color"),
|
|
new Param("type2", MarchingOrders.BackgroundType.SingleColor, "Color Type", "The way the color is applied to the background"),
|
|
new Param("colorDefault", new Color(), "Wall Color", "Sets the color of the wall"),
|
|
new Param("colorPipe", new Color(), "Pipes Color", "Sets the color of the pipes"),
|
|
new Param("colorFloor", new Color(), "Floor Color", "Sets the color of the floor and conveyer belt"),
|
|
new Param("colorFill", new Color(), "Fill Color", "Sets the fill color")
|
|
}
|
|
},*/
|
|
}, // this cause problems with the background
|
|
new List<string>() { "agb", "normal" },
|
|
"agbmarcher", "en",
|
|
new List<string>() { "en", "jp" }
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
namespace HeavenStudio.Games
|
|
{
|
|
using Scripts_MarchingOrders;
|
|
public class MarchingOrders : Minigame
|
|
{
|
|
public static MarchingOrders instance;
|
|
|
|
[Header("Sarge")]
|
|
public Animator Sarge;
|
|
public Animator Steam;
|
|
|
|
[Header("Cadets")]
|
|
public Animator Cadet1;
|
|
public Animator Cadet2;
|
|
public Animator Cadet3;
|
|
public Animator CadetPlayer;
|
|
public Animator CadetHead1;
|
|
public Animator CadetHead2;
|
|
public Animator CadetHead3;
|
|
public Animator CadetHeadPlayer;
|
|
|
|
[Header("Background")]
|
|
public GameObject BGMain1;
|
|
public SpriteRenderer Background;
|
|
public SpriteRenderer Pipes;
|
|
public SpriteRenderer Floor;
|
|
public SpriteRenderer Wall;
|
|
public SpriteRenderer Conveyor;
|
|
|
|
[Header("Color Map")]
|
|
public static Color pipesColor;
|
|
public static Color floorColor;
|
|
public static Color wallColor;
|
|
public static Color fillColor;
|
|
|
|
[Header("Game Events")]
|
|
bool goBop;
|
|
public GameEvent bop = new GameEvent();
|
|
public GameEvent noBop = new GameEvent();
|
|
public GameEvent marching = new GameEvent();
|
|
|
|
private int marchOtherCount;
|
|
private int marchPlayerCount;
|
|
private int turnLength;
|
|
private int background;
|
|
private float steamTime;
|
|
|
|
static float wantMarch = float.MaxValue;
|
|
static float wantMarchLength = 0f;
|
|
|
|
public enum DirectionFaceTurn
|
|
{
|
|
Right,
|
|
Left,
|
|
}
|
|
public enum FaceTurnLength
|
|
{
|
|
Normal,
|
|
Fast,
|
|
}
|
|
public enum BackgroundColor
|
|
{
|
|
Blue,
|
|
Yellow,
|
|
Custom,
|
|
}
|
|
public enum BackgroundType
|
|
{
|
|
SingleColor,
|
|
DifferentColor
|
|
}
|
|
// Start is called before the first frame update
|
|
void Awake()
|
|
{
|
|
instance = this;
|
|
}
|
|
|
|
public void LeftSuccess(PlayerActionEvent caller, float state)
|
|
{
|
|
if (state <= -1f || state >= 1f)
|
|
{
|
|
Jukebox.PlayOneShot("nearNiss");
|
|
}
|
|
else
|
|
Jukebox.PlayOneShotGame("marchingOrders/turnActionPlayer");
|
|
CadetHeadPlayer.DoScaledAnimationAsync("FaceL", 0.5f);
|
|
}
|
|
|
|
public void GenericMiss(PlayerActionEvent caller)
|
|
{
|
|
Jukebox.PlayOneShot("miss");
|
|
Sarge.DoScaledAnimationAsync("Anger", 0.5f);
|
|
Steam.DoScaledAnimationAsync("Steam", 0.5f);
|
|
}
|
|
|
|
public void LeftEmpty(PlayerActionEvent caller) {}
|
|
|
|
public void RightSuccess(PlayerActionEvent caller, float state)
|
|
{
|
|
if (state <= -1f || state >= 1f)
|
|
{
|
|
Jukebox.PlayOneShot("nearNiss");
|
|
}
|
|
else
|
|
Jukebox.PlayOneShotGame("marchingOrders/turnActionPlayer");
|
|
CadetHeadPlayer.DoScaledAnimationAsync("FaceR", 0.5f);
|
|
}
|
|
|
|
public void RightEmpty(PlayerActionEvent caller) {}
|
|
|
|
public void MarchHit(PlayerActionEvent caller, float state)
|
|
{
|
|
if (state <= -1f || state >= 1f)
|
|
{
|
|
Jukebox.PlayOneShot("nearNiss");
|
|
}
|
|
else
|
|
Jukebox.PlayOneShotGame("marchingOrders/stepPlayer", volume: 0.25f);
|
|
marchPlayerCount++;
|
|
CadetPlayer.DoScaledAnimationAsync(marchPlayerCount % 2 != 0 ? "MarchR" : "MarchL", 0.5f);
|
|
}
|
|
|
|
public void MarchEmpty(PlayerActionEvent caller) {}
|
|
|
|
public void HaltHit(PlayerActionEvent caller, float state)
|
|
{
|
|
if (state <= -1f || state >= 1f)
|
|
{
|
|
Jukebox.PlayOneShot("nearNiss");
|
|
}
|
|
else
|
|
Jukebox.PlayOneShotGame("marchingOrders/stepPlayer", volume: 0.25f);
|
|
CadetPlayer.DoScaledAnimationAsync("Halt", 0.5f);
|
|
}
|
|
|
|
public void HaltEmpty(PlayerActionEvent caller) {}
|
|
|
|
// Update is called once per frame
|
|
void Update()
|
|
{
|
|
var cond = Conductor.instance;
|
|
var currBeat = cond.songPositionInBeats;
|
|
|
|
if (cond.songPositionInBeatsAsDouble >= wantMarch)
|
|
{
|
|
PrepareMarch(wantMarch, wantMarchLength, true);
|
|
wantMarch = float.MaxValue;
|
|
}
|
|
|
|
if (cond.ReportBeat(ref bop.lastReportedBeat, bop.startBeat % 1, true))
|
|
{
|
|
if (goBop)
|
|
{
|
|
Cadet1.DoScaledAnimationAsync("Bop", 0.5f);
|
|
Cadet2.DoScaledAnimationAsync("Bop", 0.5f);
|
|
Cadet3.DoScaledAnimationAsync("Bop", 0.5f);
|
|
CadetPlayer.DoScaledAnimationAsync("Bop", 0.5f);
|
|
}
|
|
}
|
|
|
|
if (!IsExpectingInputNow(InputType.STANDARD_DOWN))
|
|
{
|
|
if (PlayerInput.Pressed())
|
|
{
|
|
Jukebox.PlayOneShot("miss");
|
|
Sarge.DoScaledAnimationAsync("Anger", 0.5f);
|
|
Steam.DoScaledAnimationAsync("Steam", 0.5f);
|
|
|
|
marchPlayerCount++;
|
|
var marchPlayerAnim = (marchPlayerCount % 2 != 0 ? "MarchR" : "MarchL");
|
|
|
|
CadetPlayer.DoScaledAnimationAsync(marchPlayerAnim, 0.5f);
|
|
}
|
|
}
|
|
if (!IsExpectingInputNow(InputType.STANDARD_ALT_DOWN))
|
|
{
|
|
if (PlayerInput.AltPressed())
|
|
{
|
|
Jukebox.PlayOneShot("miss");
|
|
Sarge.DoScaledAnimationAsync("Anger", 0.5f);
|
|
Steam.DoScaledAnimationAsync("Steam", 0.5f);
|
|
|
|
CadetPlayer.DoScaledAnimationAsync("Halt", 0.5f);
|
|
}
|
|
}
|
|
if (!IsExpectingInputNow(InputType.DIRECTION_LEFT_DOWN))
|
|
{
|
|
if (PlayerInput.Pressed(true) && PlayerInput.GetSpecificDirection(PlayerInput.LEFT))
|
|
{
|
|
Jukebox.PlayOneShot("miss");
|
|
Sarge.DoScaledAnimationAsync("Anger", 0.5f);
|
|
Steam.DoScaledAnimationAsync("Steam", 0.5f);
|
|
|
|
CadetHeadPlayer.DoScaledAnimationAsync("FaceL", 0.5f);
|
|
}
|
|
}
|
|
if (!IsExpectingInputNow(InputType.DIRECTION_RIGHT_DOWN))
|
|
{
|
|
if (PlayerInput.Pressed(true) && PlayerInput.GetSpecificDirection(PlayerInput.RIGHT))
|
|
{
|
|
Jukebox.PlayOneShot("miss");
|
|
Sarge.DoScaledAnimationAsync("Anger", 0.5f);
|
|
Steam.DoScaledAnimationAsync("Steam", 0.5f);
|
|
|
|
CadetHeadPlayer.DoScaledAnimationAsync("FaceR", 0.5f);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void BopAction(float beat, float length, bool shouldBop, bool autoBop)
|
|
{
|
|
goBop = autoBop;
|
|
if (shouldBop)
|
|
{
|
|
for (int i = 0; i < length; i++)
|
|
{
|
|
BeatAction.New(instance.gameObject, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beat + i, delegate
|
|
{
|
|
Cadet1.DoScaledAnimationAsync("Bop", 0.5f);
|
|
Cadet2.DoScaledAnimationAsync("Bop", 0.5f);
|
|
Cadet3.DoScaledAnimationAsync("Bop", 0.5f);
|
|
CadetPlayer.DoScaledAnimationAsync("Bop", 0.5f);
|
|
})
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
public static void PreMarch(float beat, float length)
|
|
{
|
|
wantMarch = beat - 1;
|
|
wantMarchLength = length;
|
|
}
|
|
|
|
public void PrepareMarch(float beat, float length = 0, bool first = false)
|
|
{
|
|
if (GameManager.instance.currentGame != "marchingOrders")
|
|
return;
|
|
if (first)
|
|
{
|
|
marching.length = length;
|
|
marching.startBeat = beat + 1;
|
|
|
|
marchOtherCount = 0;
|
|
marchPlayerCount = 0;
|
|
}
|
|
else
|
|
{
|
|
marchOtherCount++;
|
|
Cadet1.DoScaledAnimationAsync(marchOtherCount % 2 != 0 ? "MarchR" : "MarchL", 0.5f);
|
|
Cadet2.DoScaledAnimationAsync(marchOtherCount % 2 != 0 ? "MarchR" : "MarchL", 0.5f);
|
|
Cadet3.DoScaledAnimationAsync(marchOtherCount % 2 != 0 ? "MarchR" : "MarchL", 0.5f);
|
|
}
|
|
|
|
if (beat + 1 < marching.startBeat + marching.length)
|
|
{
|
|
Debug.Log($"PrepareMarch next {beat + 1}, {marching.startBeat}, {marching.length}");
|
|
BeatAction.New(gameObject, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beat + 1f, delegate {
|
|
PrepareMarch(beat + 1);
|
|
MultiSound.Play(new MultiSound.Sound[] {
|
|
new MultiSound.Sound("marchingOrders/stepOther", beat + 1),
|
|
}, true);
|
|
}),
|
|
});
|
|
ScheduleInput(beat, 1f, InputType.STANDARD_DOWN, MarchHit, GenericMiss, MarchEmpty);
|
|
}
|
|
}
|
|
|
|
public void SargeAttention(float beat)
|
|
{
|
|
BeatAction.New(gameObject, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beat + 0.25f, delegate { Sarge.DoScaledAnimationAsync("Talk", 0.5f);}),
|
|
});
|
|
}
|
|
|
|
public void SargeMarch(float beat, bool noVoice)
|
|
{
|
|
marchOtherCount = 0;
|
|
marchPlayerCount = 0;
|
|
MarchSound(beat, noVoice);
|
|
|
|
if (!noVoice)
|
|
Sarge.DoScaledAnimationAsync("Talk", 0.5f);
|
|
BeatAction.New(gameObject, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beat + 1f, delegate { Cadet1.DoScaledAnimationAsync("MarchL", 0.5f);}),
|
|
new BeatAction.Action(beat + 1f, delegate { Cadet2.DoScaledAnimationAsync("MarchL", 0.5f);}),
|
|
new BeatAction.Action(beat + 1f, delegate { Cadet3.DoScaledAnimationAsync("MarchL", 0.5f);}),
|
|
new BeatAction.Action(beat + 1f, delegate { CadetPlayer.DoScaledAnimationAsync("MarchL", 0.5f);}),
|
|
});
|
|
}
|
|
|
|
public void SargeHalt(float beat)
|
|
{
|
|
HaltSound(beat);
|
|
|
|
ScheduleInput(beat, 1f, InputType.STANDARD_ALT_DOWN, HaltHit, GenericMiss, HaltEmpty);
|
|
BeatAction.New(gameObject, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beat, delegate { Sarge.DoScaledAnimationAsync("Talk", 0.5f);}),
|
|
new BeatAction.Action(beat + 1f, delegate { Cadet1.DoScaledAnimationAsync("Halt", 0.5f);}),
|
|
new BeatAction.Action(beat + 1f, delegate { Cadet2.DoScaledAnimationAsync("Halt", 0.5f);}),
|
|
new BeatAction.Action(beat + 1f, delegate { Cadet3.DoScaledAnimationAsync("Halt", 0.5f);}),
|
|
});
|
|
}
|
|
|
|
public void SargeFaceTurn(float beat, int type, int type2, bool toggle)
|
|
{
|
|
string fastTurn = "";
|
|
switch (type2)
|
|
{
|
|
case (int) MarchingOrders.FaceTurnLength.Fast:
|
|
turnLength = 0;
|
|
fastTurn = "fast";
|
|
break;
|
|
default:
|
|
turnLength = 1;
|
|
fastTurn = "";
|
|
break;
|
|
}
|
|
|
|
|
|
switch (type)
|
|
{
|
|
case (int) MarchingOrders.DirectionFaceTurn.Left:
|
|
ScheduleInput(beat, turnLength + 2f, InputType.DIRECTION_LEFT_DOWN, LeftSuccess, GenericMiss, LeftEmpty);
|
|
MultiSound.Play(new MultiSound.Sound[] {
|
|
new MultiSound.Sound("marchingOrders/leftFaceTurn1" + fastTurn, beat),
|
|
new MultiSound.Sound("marchingOrders/leftFaceTurn2" + fastTurn, beat + 0.5f),
|
|
new MultiSound.Sound("marchingOrders/leftFaceTurn3", beat + turnLength + 1f),
|
|
new MultiSound.Sound("marchingOrders/turnAction", beat + turnLength + 2f),
|
|
}, forcePlay: true);
|
|
|
|
BeatAction.New(gameObject, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beat + turnLength + 2f, delegate { if (!toggle) CadetHead1.DoScaledAnimationAsync("FaceL", 0.5f);
|
|
else Cadet1.DoScaledAnimationAsync("PointL"); }),
|
|
new BeatAction.Action(beat + turnLength + 2f, delegate { if (!toggle) CadetHead2.DoScaledAnimationAsync("FaceL", 0.5f);
|
|
else Cadet2.DoScaledAnimationAsync("PointL");}),
|
|
new BeatAction.Action(beat + turnLength + 2f, delegate { if (!toggle) CadetHead3.DoScaledAnimationAsync("FaceL", 0.5f);
|
|
else Cadet3.DoScaledAnimationAsync("PointL");}),
|
|
});
|
|
break;
|
|
default:
|
|
ScheduleInput(beat, turnLength + 2f, InputType.DIRECTION_RIGHT_DOWN, RightSuccess, GenericMiss, RightEmpty);
|
|
MultiSound.Play(new MultiSound.Sound[] {
|
|
new MultiSound.Sound("marchingOrders/rightFaceTurn1" + fastTurn, beat),
|
|
new MultiSound.Sound("marchingOrders/rightFaceTurn2" + fastTurn, beat + 0.5f),
|
|
new MultiSound.Sound("marchingOrders/rightFaceTurn3", beat + turnLength + 1f),
|
|
new MultiSound.Sound("marchingOrders/turnAction", beat + turnLength + 2f),
|
|
}, forcePlay: true);
|
|
|
|
BeatAction.New(gameObject, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beat + turnLength + 2f, delegate { if (!toggle) CadetHead1.DoScaledAnimationAsync("FaceR", 0.5f);
|
|
else Cadet1.DoScaledAnimationAsync("PointR");}),
|
|
new BeatAction.Action(beat + turnLength + 2f, delegate { if (!toggle) CadetHead2.DoScaledAnimationAsync("FaceR", 0.5f);
|
|
else Cadet2.DoScaledAnimationAsync("PointR");}),
|
|
new BeatAction.Action(beat + turnLength + 2f, delegate { if (!toggle) CadetHead3.DoScaledAnimationAsync("FaceR", 0.5f);
|
|
else Cadet3.DoScaledAnimationAsync("PointR");}),
|
|
});
|
|
break;
|
|
}
|
|
|
|
BeatAction.New(gameObject, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beat, delegate { Sarge.DoScaledAnimationAsync("Talk", 0.5f);}),
|
|
new BeatAction.Action(beat + turnLength + 1f, delegate { Sarge.DoScaledAnimationAsync("Talk", 0.5f);}),
|
|
});
|
|
}
|
|
|
|
/*public void BackgroundColorSet(float beat, int type, int colorType, Color wall, Color pipes, Color floor, Color fill)
|
|
{
|
|
background = type;
|
|
if (colorType == (int) MarchingOrders.BackgroundColor.Custom)
|
|
{
|
|
pipesColor = pipes;
|
|
floorColor = floor;
|
|
wallColor = wall;
|
|
fillColor = fill;
|
|
}
|
|
Pipes.color = pipesColor;
|
|
UpdateMaterialColour(pipes, floor, wall);
|
|
}
|
|
|
|
public static void UpdateMaterialColour(Color mainCol, Color highlightCol, Color objectCol)
|
|
{
|
|
pipesColor = mainCol;
|
|
floorColor = highlightCol;
|
|
wallColor = objectCol;
|
|
}*/
|
|
|
|
public static void AttentionSound(float beat)
|
|
{
|
|
PlaySoundSequence("marchingOrders", "zentai", beat - 1);
|
|
}
|
|
|
|
public static void MarchSound(float beat, bool noVoice)
|
|
{
|
|
if (!noVoice)
|
|
{
|
|
PlaySoundSequence("marchingOrders", "susume", beat);
|
|
}
|
|
}
|
|
|
|
public static void HaltSound(float beat)
|
|
{
|
|
PlaySoundSequence("marchingOrders", "tomare", beat);
|
|
}
|
|
}
|
|
}
|
|
|