mirror of
https://github.com/RHeavenStudioPlus/HeavenStudioPlus.git
synced 2024-11-10 11:45:09 +00:00
669 lines
25 KiB
C#
669 lines
25 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;
|
|
/// Minigame loaders handle the setup of your minigame.
|
|
/// Here, you designate the game prefab, define entities, and mark what AssetBundle to load
|
|
|
|
/// Names of minigame loaders follow a specific naming convention of `PlatformcodeNameLoader`, where:
|
|
/// `Platformcode` is a three-leter platform code with the minigame's origin
|
|
/// `Name` is a short internal name
|
|
/// `Loader` is the string "Loader"
|
|
|
|
/// Platform codes are as follows:
|
|
/// Agb: Gameboy Advance ("Advance Gameboy")
|
|
/// Ntr: Nintendo DS ("Nitro")
|
|
/// Rvl: Nintendo Wii ("Revolution")
|
|
/// Ctr: Nintendo 3DS ("Centrair")
|
|
/// Mob: Mobile
|
|
/// Pco: PC / Other
|
|
|
|
/// Fill in the loader class label, "*prefab name*", and "*Display Name*" with the relevant information
|
|
/// For help, feel free to reach out to us on our discord, in the #development channel.
|
|
public static class AgbRhythmTestGBALoader
|
|
{
|
|
public static Minigame AddGame(EventCaller eventCaller)
|
|
{
|
|
return new Minigame("rhythmTestGBA", "Rhythm Test (GBA) \n<color=#adadad>(Rhythm-kan Check)</color>", "2DD816", false, false, new List<GameAction>()
|
|
{
|
|
|
|
new GameAction("countin", "Start Beeping")
|
|
{
|
|
function = delegate { RhythmTestGBA.instance.KeepTheBeep(eventCaller.currentEntity.beat, eventCaller.currentEntity.length, eventCaller.currentEntity["toggle"], eventCaller.currentEntity["auto"]); },
|
|
defaultLength = 1f,
|
|
resizable = true,
|
|
parameters = new List<Param>()
|
|
{
|
|
new Param("toggle", true, "Toggle", "Toggle the automatic beeping on or off."),
|
|
new Param("auto", false, "Auto", "Toggle if the machine should beep automatically."),
|
|
},
|
|
},
|
|
|
|
new GameAction("button", "Start Keep-the-Beat")
|
|
{
|
|
function = delegate { var e = eventCaller.currentEntity; RhythmTestGBA.StartKeepbeat(e.beat); },
|
|
defaultLength = 1f,
|
|
resizable = false,
|
|
|
|
},
|
|
|
|
new GameAction("stopktb", "Stop Keep-the-Beat")
|
|
{
|
|
preFunction = delegate { RhythmTestGBA.instance.PreStopKeepbeat(eventCaller.currentEntity.beat, eventCaller.currentEntity.length, eventCaller.currentEntity["mutecue"]); },
|
|
defaultLength = 4f,
|
|
resizable = false,
|
|
parameters = new List<Param>()
|
|
{
|
|
new Param("mutecue", false, "Mute Cue", "Mute the sound cue signifying the end of the keep-the-beat section."),
|
|
}
|
|
},
|
|
|
|
new GameAction("countdown", "Countdown")
|
|
{
|
|
function = delegate {RhythmTestGBA.instance.PreCountDown(eventCaller.currentEntity.beat, eventCaller.currentEntity.length, eventCaller.currentEntity["val1"]);},
|
|
defaultLength = 1f,
|
|
resizable = true,
|
|
parameters = new List<Param>()
|
|
{
|
|
new Param("val1", new EntityTypes.Integer(1, 9, 3), "Beats", "Set how many beats there will be before the player has to input.")
|
|
}
|
|
},
|
|
|
|
new GameAction("hidecount", "Toggle Countdown")
|
|
{
|
|
function = delegate {RhythmTestGBA.instance.HideCountdown(eventCaller.currentEntity["togglecount"]);},
|
|
defaultLength = 0.5f,
|
|
resizable = false,
|
|
parameters = new List<Param>()
|
|
{
|
|
new Param("togglecount", true, "Toggle Countdown?", "Toggles whether the countdown appears or not."),
|
|
}
|
|
|
|
},
|
|
|
|
},
|
|
new List<string>() {"agb", "aim"},
|
|
"agbRhythmTestGBA", "en",
|
|
new List<string>() { "en" },
|
|
chronologicalSortKey: 0
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
namespace HeavenStudio.Games
|
|
{
|
|
/// This class handles the minigame logic.
|
|
/// Minigame inherits directly from MonoBehaviour, and adds Heaven Studio specific methods to override.
|
|
public class RhythmTestGBA : Minigame
|
|
{
|
|
public static RhythmTestGBA instance;
|
|
static List<double> queuedButton = new();
|
|
|
|
bool goBeep;
|
|
//bool stopBeep; Unused value - Marc
|
|
bool keepPressing;
|
|
bool shouldmute;
|
|
bool disableCount;
|
|
|
|
private double numberSelect;
|
|
private float countLength;
|
|
|
|
[Header("Animators")]
|
|
[SerializeField] Animator buttonAnimator;
|
|
[SerializeField] Animator flashAnimator;
|
|
[SerializeField] Animator numberBGAnimator;
|
|
[SerializeField] Animator numberAnimator;
|
|
|
|
[Header("Properties")]
|
|
//private static double startBlippingBeat = double.MaxValue; Unused value - Marc
|
|
|
|
[Header("Variables")]
|
|
|
|
//int pressPlayerCount; Unused value - Marc
|
|
public static double wantButton = double.MinValue;
|
|
|
|
GameEvent button = new GameEvent();
|
|
|
|
double lastButton = double.MaxValue;
|
|
|
|
// public struct QueuedButton
|
|
// {
|
|
// public double beat;
|
|
// public float length;
|
|
// }
|
|
// static List<QueuedButton> queuedButton = new List<QueuedButton>();
|
|
|
|
private void Awake()
|
|
{
|
|
instance = this;
|
|
|
|
}
|
|
|
|
void OnDestroy()
|
|
{
|
|
if (queuedButton.Count > 0) queuedButton.Clear();
|
|
foreach (var ktb in scheduledInputs)
|
|
{
|
|
ktb.Disable();
|
|
}
|
|
}
|
|
|
|
|
|
private void Update()
|
|
{
|
|
var cond = Conductor.instance;
|
|
|
|
if (PlayerInput.GetIsAction(InputAction_BasicPress) && !IsExpectingInputNow(InputAction_BasicPress))
|
|
{
|
|
PressButton();
|
|
//print("unexpected input");
|
|
}
|
|
|
|
if (wantButton != double.MinValue)
|
|
{
|
|
queuedButton.Add(wantButton);
|
|
keepPressing = true;
|
|
//pressPlayerCount = 0; Unused value - Marc
|
|
wantButton = double.MinValue;
|
|
}
|
|
|
|
if (Conductor.instance.isPlaying && !Conductor.instance.isPaused)
|
|
{
|
|
|
|
if (queuedButton.Count > 0)
|
|
{
|
|
|
|
foreach (var ktb in queuedButton)
|
|
{
|
|
BeatAction.New(instance, new List<BeatAction.Action>() {
|
|
new BeatAction.Action(ktb, delegate {
|
|
ScheduleInput(ktb, 1f, InputAction_BasicPress, ButtonSuccess, ButtonFailure, ButtonEmpty);
|
|
|
|
}),
|
|
new BeatAction.Action(ktb + 1, delegate {
|
|
if (keepPressing) queuedButton.Add(ktb + 1);
|
|
}),
|
|
});
|
|
}
|
|
queuedButton.Clear();
|
|
}
|
|
}
|
|
|
|
if (lastButton + 1 <= cond.songPositionInBeatsAsDouble)
|
|
{
|
|
lastButton++;
|
|
ScheduleInput(lastButton, 1, InputAction_BasicPress, ButtonSuccess, ButtonFailure, ButtonEmpty);
|
|
|
|
}
|
|
}
|
|
|
|
public void KeepTheBeep(double beat, float length, bool shouldBeep, bool autoBeep)
|
|
{
|
|
//stopBeep = false; Unused value - Marc
|
|
if (!shouldBeep) { goBeep = false; return;}
|
|
goBeep = autoBeep;
|
|
if (shouldBeep)
|
|
{
|
|
for (int i = 0; i < length; i++)
|
|
{
|
|
BeatAction.New(instance, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beat + i, delegate
|
|
{
|
|
PlayFlashFX();
|
|
SoundByte.PlayOneShotGame("rhythmTestGBA/blip");
|
|
|
|
})
|
|
});
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
public void PlayFlashFX()
|
|
{
|
|
numberAnimator.Play("Idle");
|
|
numberBGAnimator.Play("Idle");
|
|
flashAnimator.Play("KTBPulse", 0 ,0);
|
|
}
|
|
|
|
|
|
|
|
public void PressButton()
|
|
{
|
|
SoundByte.PlayOneShotGame("rhythmTestGBA/press");
|
|
|
|
buttonAnimator.Play("Press", 0, 0);
|
|
|
|
}
|
|
|
|
public void PreStopKeepbeat(double beat, float length, bool muted)
|
|
{
|
|
shouldmute = muted;
|
|
BeatAction.New(instance, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beat-1, delegate {killBeeps(beat);}),
|
|
new BeatAction.Action(beat, delegate {StopKeepbeat(beat, shouldmute);})
|
|
});
|
|
|
|
|
|
}
|
|
|
|
|
|
public void StopKeepbeat(double beat, bool shouldmute)
|
|
{
|
|
|
|
|
|
keepPressing = false;
|
|
ScheduleInput(beat, 1f, InputAction_BasicPress, ButtonSuccess, ButtonFailure, ButtonEmpty);
|
|
ScheduleInput(beat, 2f, InputAction_BasicPress, ButtonSuccess, ButtonFailure, ButtonEmpty);
|
|
ScheduleInput(beat, 3f, InputAction_BasicPress, ButtonSuccess, ButtonFailure, ButtonEmpty);
|
|
|
|
|
|
|
|
BeatAction.New(instance, new List<BeatAction.Action>()
|
|
{
|
|
|
|
new BeatAction.Action(beat, delegate {PlayFlashFX();}),
|
|
|
|
new BeatAction.Action(beat+1, delegate {PlayFlashFX();}),
|
|
|
|
new BeatAction.Action(beat+2, delegate {PlayFlashFX();}),
|
|
|
|
new BeatAction.Action(beat+3, delegate { SoundByte.PlayOneShotGame("rhythmTestGBA/end_ding", beat: beat, forcePlay: true);})
|
|
|
|
});
|
|
if (!shouldmute)
|
|
{
|
|
SoundByte.PlayOneShotGame("rhythmTestGBA/blip2");
|
|
BeatAction.New(instance, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beat+1, delegate { SoundByte.PlayOneShotGame("rhythmTestGBA/blip2", beat: beat);}),
|
|
new BeatAction.Action(beat+2, delegate { SoundByte.PlayOneShotGame("rhythmTestGBA/blip2", beat: beat);})
|
|
});
|
|
|
|
}
|
|
}
|
|
|
|
|
|
public void StopKeepbeatInput(double beat)
|
|
{
|
|
ScheduleInput(beat, 0f, InputAction_BasicPress, ButtonSuccess, ButtonFailure, ButtonEmpty);
|
|
PlayFlashFX();
|
|
}
|
|
|
|
public override void OnBeatPulse(double beat)
|
|
{
|
|
if (goBeep)
|
|
{
|
|
PlayFlashFX();
|
|
SoundByte.PlayOneShotGame("rhythmTestGBA/blip");
|
|
}
|
|
|
|
}
|
|
|
|
public void killBeeps(double beat)
|
|
{
|
|
goBeep = false;
|
|
}
|
|
|
|
|
|
|
|
public static void StartKeepbeat(double beat)
|
|
{
|
|
RhythmTestGBA.wantButton = beat-1;
|
|
|
|
|
|
}
|
|
|
|
|
|
public void PreCountDown(double startBeat, float length, int countdownNumber)
|
|
{
|
|
if (keepPressing) return;
|
|
ScheduleInput(startBeat, length * countdownNumber, InputAction_BasicPress, ButtonSuccess, ButtonFailure, ButtonEmpty);
|
|
countLength = length;
|
|
switch (countdownNumber)
|
|
{
|
|
case 1:
|
|
CountOne(startBeat, length);
|
|
break;
|
|
case 2:
|
|
CountTwo(startBeat, length);
|
|
break;
|
|
case 3:
|
|
CountThree(startBeat, length);
|
|
break;
|
|
case 4:
|
|
CountFour(startBeat, length);
|
|
break;
|
|
case 5:
|
|
CountFive(startBeat, length);
|
|
break;
|
|
case 6:
|
|
CountSix(startBeat, length);
|
|
break;
|
|
case 7:
|
|
CountSeven(startBeat, length);
|
|
break;
|
|
case 8:
|
|
CountEight(startBeat, length);
|
|
break;
|
|
case 9:
|
|
CountNine(startBeat, length);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Countdown playing functions
|
|
|
|
public void CountNine(double startBeat, float length)
|
|
{
|
|
|
|
BeatAction.New(instance, new List<BeatAction.Action>()
|
|
{
|
|
|
|
new BeatAction.Action(startBeat, delegate {FlashNine(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length, delegate {FlashEight(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*2, delegate {FlashSeven(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*3, delegate {FlashSix(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*4, delegate {FlashFive(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*5, delegate {FlashFour(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*6, delegate {FlashThree(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*7, delegate {FlashTwo(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*8, delegate {FlashOne(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*9, delegate {FlashZero(startBeat);})
|
|
});
|
|
}
|
|
|
|
|
|
public void CountEight(double startBeat, float length)
|
|
{
|
|
BeatAction.New(instance, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(startBeat, delegate {FlashEight(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length, delegate {FlashSeven(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*2, delegate {FlashSix(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*3, delegate {FlashFive(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*4, delegate {FlashFour(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*5, delegate {FlashThree(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*6, delegate {FlashTwo(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*7, delegate {FlashOne(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*8, delegate {FlashZero(startBeat);})
|
|
});
|
|
|
|
}
|
|
public void CountSeven(double startBeat, float length)
|
|
{
|
|
BeatAction.New(instance, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(startBeat, delegate {FlashSeven(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length, delegate {FlashSix(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*2, delegate {FlashFive(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*3, delegate {FlashFour(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*4, delegate {FlashThree(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*5, delegate {FlashTwo(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*6, delegate {FlashOne(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*7, delegate {FlashZero(startBeat);})
|
|
});
|
|
}
|
|
public void CountSix(double startBeat, float length)
|
|
{
|
|
BeatAction.New(instance, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(startBeat, delegate {FlashSix(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length, delegate {FlashFive(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*2, delegate {FlashFour(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*3, delegate {FlashThree(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*4, delegate {FlashTwo(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*5, delegate {FlashOne(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*6, delegate {FlashZero(startBeat);})
|
|
});
|
|
}
|
|
public void CountFive(double startBeat, float length)
|
|
{
|
|
BeatAction.New(instance, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(startBeat, delegate {FlashFive(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length, delegate {FlashFour(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*2, delegate {FlashThree(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*3, delegate {FlashTwo(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*4, delegate {FlashOne(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*5, delegate {FlashZero(startBeat);})
|
|
});
|
|
}
|
|
public void CountFour(double startBeat, float length)
|
|
{
|
|
BeatAction.New(instance, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(startBeat, delegate {FlashFour(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length, delegate {FlashThree(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*2, delegate {FlashTwo(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*3, delegate {FlashOne(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*4, delegate {FlashZero(startBeat);})
|
|
});
|
|
}
|
|
public void CountThree(double startBeat, float length)
|
|
{
|
|
BeatAction.New(instance, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(startBeat, delegate {FlashThree(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length, delegate {FlashTwo(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*2, delegate {FlashOne(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*3, delegate {FlashZero(startBeat);})
|
|
});
|
|
}
|
|
public void CountTwo(double startBeat, float length)
|
|
{
|
|
BeatAction.New(instance, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(startBeat, delegate {FlashTwo(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length, delegate {FlashOne(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length*2, delegate {FlashZero(startBeat);})
|
|
});
|
|
}
|
|
public void CountOne(double startBeat, float length)
|
|
{
|
|
BeatAction.New(instance, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(startBeat, delegate {FlashOne(startBeat, disableCount);}),
|
|
new BeatAction.Action(startBeat + length, delegate {FlashZero(startBeat);})
|
|
});
|
|
}
|
|
// Number Call Functions
|
|
|
|
public void HideCountdown(bool toggleCount)
|
|
{
|
|
if (toggleCount)
|
|
{
|
|
disableCount = false;
|
|
}
|
|
else
|
|
{
|
|
disableCount = true;
|
|
}
|
|
}
|
|
|
|
public void FlashNine(double beat, bool disableCount)
|
|
{
|
|
if (disableCount != true)
|
|
{
|
|
numberBGAnimator.Play("FlashBG", -1, 0);
|
|
numberAnimator.Play("Nine");
|
|
SoundByte.PlayOneShotGame("rhythmTestGBA/blip2");
|
|
}
|
|
else
|
|
{
|
|
numberBGAnimator.Play("Idle");
|
|
numberAnimator.Play("Idle");
|
|
}
|
|
}
|
|
|
|
public void FlashEight(double beat, bool disableCount)
|
|
{
|
|
if (!disableCount)
|
|
{
|
|
numberBGAnimator.Play("FlashBG", -1, 0);
|
|
numberAnimator.Play("Eight");
|
|
SoundByte.PlayOneShotGame("rhythmTestGBA/blip2");
|
|
}
|
|
else
|
|
{
|
|
numberBGAnimator.Play("Idle");
|
|
numberAnimator.Play("Idle");
|
|
}
|
|
}
|
|
|
|
public void FlashSeven(double beat, bool disableCount)
|
|
{
|
|
if (!disableCount)
|
|
{
|
|
numberBGAnimator.Play("FlashBG", -1, 0);
|
|
numberAnimator.Play("Seven");
|
|
SoundByte.PlayOneShotGame("rhythmTestGBA/blip2");
|
|
}
|
|
else
|
|
{
|
|
numberBGAnimator.Play("Idle");
|
|
numberAnimator.Play("Idle");
|
|
}
|
|
}
|
|
|
|
public void FlashSix(double beat, bool disableCount)
|
|
{
|
|
if (!disableCount)
|
|
{
|
|
numberBGAnimator.Play("FlashBG", -1, 0);
|
|
numberAnimator.Play("Six");
|
|
SoundByte.PlayOneShotGame("rhythmTestGBA/blip2");
|
|
}
|
|
else
|
|
{
|
|
numberBGAnimator.Play("Idle");
|
|
numberAnimator.Play("Idle");
|
|
}
|
|
}
|
|
|
|
public void FlashFive(double beat, bool disableCount)
|
|
{
|
|
if (!disableCount)
|
|
{
|
|
numberBGAnimator.Play("FlashBG", -1, 0);
|
|
numberAnimator.Play("Five");
|
|
SoundByte.PlayOneShotGame("rhythmTestGBA/blip2");
|
|
}
|
|
else
|
|
{
|
|
numberBGAnimator.Play("Idle");
|
|
numberAnimator.Play("Idle");
|
|
}
|
|
}
|
|
|
|
public void FlashFour(double beat, bool disableCount)
|
|
{
|
|
if (!disableCount)
|
|
{
|
|
numberBGAnimator.Play("FlashBG", -1, 0);
|
|
numberAnimator.Play("Four");
|
|
SoundByte.PlayOneShotGame("rhythmTestGBA/blip2");
|
|
}
|
|
else
|
|
{
|
|
numberBGAnimator.Play("Idle");
|
|
numberAnimator.Play("Idle");
|
|
}
|
|
}
|
|
|
|
public void FlashThree(double beat, bool disableCount)
|
|
{
|
|
if (!disableCount)
|
|
{
|
|
numberBGAnimator.Play("FlashBG", -1, 0);
|
|
numberAnimator.Play("Three");
|
|
SoundByte.PlayOneShotGame("rhythmTestGBA/blip2");
|
|
}
|
|
else
|
|
{
|
|
numberBGAnimator.Play("Idle");
|
|
numberAnimator.Play("Idle");
|
|
}
|
|
}
|
|
|
|
public void FlashTwo(double beat, bool disableCount)
|
|
{
|
|
if (!disableCount)
|
|
{
|
|
numberBGAnimator.Play("FlashBG", -1, 0);
|
|
numberAnimator.Play("Two");
|
|
SoundByte.PlayOneShotGame("rhythmTestGBA/blip2");
|
|
}
|
|
else
|
|
{
|
|
numberBGAnimator.Play("Idle");
|
|
numberAnimator.Play("Idle");
|
|
}
|
|
}
|
|
|
|
public void FlashOne(double beat, bool disableCount)
|
|
{
|
|
if (!disableCount)
|
|
{
|
|
numberBGAnimator.Play("FlashBG", -1, 0);
|
|
numberAnimator.Play("One");
|
|
SoundByte.PlayOneShotGame("rhythmTestGBA/blip2");
|
|
}
|
|
else
|
|
{
|
|
numberBGAnimator.Play("Idle");
|
|
numberAnimator.Play("Idle");
|
|
}
|
|
}
|
|
|
|
public void FlashZero(double beat)
|
|
{
|
|
|
|
numberBGAnimator.Play("FlashHit");
|
|
numberAnimator.Play("Zero");
|
|
SoundByte.PlayOneShotGame("rhythmTestGBA/blip3");
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
public void HideCountdown(double beat, bool showcount)
|
|
{
|
|
|
|
}
|
|
|
|
|
|
public void ButtonSuccess(PlayerActionEvent caller, float state)
|
|
{
|
|
PressButton();
|
|
|
|
|
|
}
|
|
|
|
public void ButtonFailure(PlayerActionEvent caller)
|
|
{
|
|
|
|
}
|
|
public void ButtonEmpty(PlayerActionEvent caller) {
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
}
|
|
}
|