HeavenStudioPlus/Assets/Scripts/Games/NightWalkAgb/AgbNightWalk.cs

704 lines
29 KiB
C#
Raw Normal View History

Nightwalk GBA (#569) * Nightwalks set up * Play yan with balloons * platformSetUp * Platform handler fundamentals * Count In Added * small thing * Got em inputs in nightwalk gba to work * Platforms now spawn when there's no count-in * He jumps now! * Decreased platform count * Height changes added * Randomness for height changes * Name changing * Fixed a bug with no count in blocks * Ok height changes should be flawless now * No jumping added * Umbrella and lollipop added * Umbrella drum pattern added * Fallyan :( * Implemented falling :( * Fixed drum patterns not working * Fish implemented * Fixed kick sound being weird * 4 beat count in added * Tweaked landing pos * Walking Count-In added * new sprites touched up anims * oops1 * barely anims * Implemented barelies into nightwalk gba * Balloons have random positioning now * New sounds and whiff/barely sounds * Fall smear added * Fixed issues with platform heights on gameswitches * 24 platforms * walk is normalized now * Star scrolling functionality done * Blink animations n stuff * STARS BLINK NOW * Force evolve added + tweaks * Fixed stars not stopping + upped amount of stars * End event setup * Finding end blocks logic added * end event functionality finished * end platform anim * fixed anim * only stars on screen evolve * 2 evolve by default * End event fixes * more blinking * star blinks now and has string * minor tweak * fix to interaction between fish and end block * tweaked dropdown values * removed fish sound * named some sprites in the spritesheet * high jump and roll anims * Roll sound should only play if valid * Small fix to roll cue sound logic * Another small fix to roll cue sound logic * ok actually fixed roll sound * roll platform added to jumpl platform prefab * Roll cue platform visuals done * Basic Roll Cue implemented * flower * umbrella * barely for roll release * OOPS * smol fixes * fixed visual stuff and added missing to rolls * redid sheet, new anims * slow walkin' * adjustments * oops * adjusted smear * improved interaction between roll and end block * improved interaction between roll cue and platform heights * 32 stars * made the star boundary way smaller * how was i this stupid * fixed more interactions * stack proof roll cue and also end block + roll cue fix * Fixed things related to stars * fixed no jumping not working with end block + roll * nearing the final stages * rolls counts for 2 jumps now * fixed a bug to do with roll platforms and made roll platform sounds not be able to be played on invalid beats * made stage 2 stars bigger * added destroy roll platform sprites * update to new systems --------- Co-authored-by: Rapandrasmus <78219215+Rapandrasmus@users.noreply.github.com> Co-authored-by: minenice55 <star.elementa@gmail.com>
2024-01-28 06:03:53 +00:00
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using HeavenStudio.Util;
using Jukebox;
using System;
using HeavenStudio.InputSystem;
namespace HeavenStudio.Games.Loaders
{
using static Minigames;
public static class AgbNightWalkLoader
{
public static Minigame AddGame(EventCaller eventCaller)
{
return new Minigame("nightWalkAgb", "Night Walk (GBA)", "FFFFFF", false, false, new List<GameAction>()
{
new GameAction("countIn8", "8 Beat Count-In")
{
preFunction = delegate { if (!eventCaller.currentEntity["mute"] && AgbNightWalk.IsValidCountIn(eventCaller.currentEntity)) AgbNightWalk.CountInSound8(eventCaller.currentEntity.beat); },
defaultLength = 8,
parameters = new List<Param>()
{
new Param("mute", false, "Mute Cowbell")
}
},
new GameAction("countIn4", "4 Beat Count-In")
{
preFunction = delegate { if (!eventCaller.currentEntity["mute"] && AgbNightWalk.IsValidCountIn(eventCaller.currentEntity)) AgbNightWalk.CountInSound4(eventCaller.currentEntity.beat); },
defaultLength = 4,
parameters = new List<Param>()
{
new Param("mute", false, "Mute Cowbell")
}
},
new GameAction("height", "Platform Height")
{
parameters = new List<Param>()
{
new Param("value", new EntityTypes.Integer(-10, 10, 1), "Height Units"),
new Param("rmin", new EntityTypes.Integer(-10, 10, 0), "Random Units (Minimum)"),
new Param("rmax", new EntityTypes.Integer(-10, 10, 0), "Random Units (Maximum)"),
}
},
new GameAction("type", "Platform Type")
{
preFunction = delegate
{
var e = eventCaller.currentEntity;
if (e["type"] == (int)AgbNightWalk.PlatformType.Umbrella)
{
AgbNightWalk.FillSound(e.beat, (AgbNightWalk.FillType)e["fill"]);
}
},
parameters = new List<Param>()
{
new Param("type", AgbNightWalk.PlatformType.Lollipop, "Type"),
new Param("fill", AgbNightWalk.FillType.None, "Umbrella Drum Pattern")
},
preFunctionLength = 1
},
new GameAction("fish", "Electric Fish")
{
},
new GameAction("roll", "Roll")
{
preFunctionLength = 1,
defaultLength = 2,
preFunction = delegate { var e = eventCaller.currentEntity; if (!e["mute"]) AgbNightWalk.PlayRollCue(e.beat, e); },
parameters = new List<Param>()
{
new Param("mute", false, "Mute Sound")
}
},
new GameAction("end", "End")
{
parameters = new List<Param>()
{
new Param("minAmount", new EntityTypes.Integer(0, 1000, 10), "Minimum Jumps Required"),
new Param("minAmountP", new EntityTypes.Integer(0, 1000, 0), "Minimum Jumps Required (Persistent)"),
}
},
new GameAction("noJump", "No Jumping")
{
defaultLength = 4,
resizable = true
},
new GameAction("walkingCountIn", "Walking Count-In")
{
preFunction = delegate { var e = eventCaller.currentEntity; AgbNightWalk.WalkingCountIn(e.beat, e.length); },
defaultLength = 4,
resizable = true
},
new GameAction("evolveAmount", "Star Evolve Amount")
{
function = delegate { AgbNightWalk.instance.evolveAmount = eventCaller.currentEntity["am"]; },
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("am", new EntityTypes.Integer(0, 100, 1), "Amount", "How many stars will evolve when play-yan jumps?"),
}
},
new GameAction("forceEvolve", "Force Star Evolve")
{
function = delegate { var e = eventCaller.currentEntity; AgbNightWalk.instance.ForceEvolve(e.beat, e.length, e["am"], e["repeat"]); },
resizable = true,
parameters = new List<Param>()
{
new Param("am", new EntityTypes.Integer(0, 100, 1), "Star Amount", "How many stars will evolve?"),
new Param("repeat", new EntityTypes.Integer(0, 100, 1), "Repeat Amount", "How many times will this event repeat?"),
}
},
});
}
}
}
namespace HeavenStudio.Games
{
using Scripts_AgbNightWalk;
public class AgbNightWalk : Minigame
{
public enum PlatformType
{
Lollipop = 2,
Umbrella = 3
}
public enum FillType
{
None,
Pattern1,
Pattern2,
Pattern3,
}
public static AgbNightWalk instance;
public AgbPlayYan playYan;
[SerializeField] private AgbPlatformHandler platformHandler;
public AgbStarHandler starHandler;
[NonSerialized] public double countInBeat = double.MinValue;
[NonSerialized] public float countInLength = 8;
[Header("Curves")]
[SerializeField] SuperCurveObject.Path[] jumpPaths;
private struct HeightEvent
{
public double beat;
public int value;
}
List<HeightEvent> heightEntityEvents = new();
[NonSerialized] public Dictionary<double, TypeEvent> platformTypes = new();
private List<double> fishBeats = new();
private List<double> rollBeats = new();
public struct TypeEvent
{
public PlatformType platformType;
public FillType fillType;
}
[NonSerialized] public int evolveAmount = 1;
[NonSerialized] public int hitJumps;
[NonSerialized] public static int hitJumpsPersist;
[NonSerialized] public double endBeat = double.MaxValue;
[NonSerialized] public int requiredJumps;
[NonSerialized] public int requiredJumpsP;
const int IAAltDownCat = IAMAXCAT;
const int IAAltUpCat = IAMAXCAT + 1;
protected static bool IA_PadAltDown(out double dt)
{
return PlayerInput.GetPadDown(InputController.ActionsPad.South, out dt);
}
protected static bool IA_BatonAltDown(out double dt)
{
return PlayerInput.GetSqueezeDown(out dt);
}
protected static bool IA_TouchAltDown(out double dt)
{
return PlayerInput.GetTouchDown(InputController.ActionsTouch.Tap, out dt)
&& instance.IsExpectingInputNow(InputAction_AltDown);
}
protected static bool IA_PadAltUp(out double dt)
{
return PlayerInput.GetPadUp(InputController.ActionsPad.South, out dt);
}
protected static bool IA_BatonAltUp(out double dt)
{
return PlayerInput.GetSqueezeUp(out dt);
}
protected static bool IA_TouchAltUp(out double dt)
{
return PlayerInput.GetFlick(out dt)
&& instance.IsExpectingInputNow(InputAction_AltUp);
}
protected static bool IA_EmptyTouchUp(out double dt)
{
return PlayerInput.GetTouchUp(InputController.ActionsTouch.Tap, out dt) && !PlayerInput.GetFlick(out _);
}
public static PlayerInput.InputAction InputAction_AltDown =
new("KarateAltDown", new int[] { IAAltDownCat, IAAltDownCat, IAAltDownCat },
IA_PadAltDown, IA_TouchAltDown, IA_BatonAltDown);
public static PlayerInput.InputAction InputAction_AltUp =
new("KarateAltUp", new int[] { IAAltUpCat, IAAltUpCat, IAAltUpCat },
IA_PadAltUp, IA_TouchAltUp, IA_BatonAltUp);
public static PlayerInput.InputAction InputAction_TouchUp =
new("KarateAltUp", new int[] { IAEmptyCat, IAReleaseCat, IAEmptyCat },
IA_PadAltUp, IA_EmptyTouchUp, IA_BatonAltUp);
new void OnDrawGizmos()
{
base.OnDrawGizmos();
foreach (SuperCurveObject.Path path in jumpPaths)
{
if (path.preview)
{
playYan.DrawEditorGizmo(path);
}
}
}
public SuperCurveObject.Path GetPath(string name)
{
foreach (SuperCurveObject.Path path in jumpPaths)
{
if (path.name == name)
{
return path;
}
}
return default(SuperCurveObject.Path);
}
private void Awake()
{
instance = this;
List<RiqEntity> heightEvents = EventCaller.GetAllInGameManagerList("nightWalkAgb", new string[] { "height" });
List<RiqEntity> rollEvents = EventCaller.GetAllInGameManagerList("nightWalkAgb", new string[] { "roll" });
var validRollEvents = rollEvents.FindAll(x => IsValidRollCue(x));
foreach (var heightEvent in heightEvents)
{
if (validRollEvents.Count > 0 && validRollEvents.Find(x => heightEvent.beat >= x.beat + 1 && heightEvent.beat < x.beat + 2) != null) continue;
heightEntityEvents.Add(new HeightEvent()
{
beat = heightEvent.beat,
value = heightEvent["value"] + UnityEngine.Random.Range(heightEvent["rmin"], heightEvent["rmax"] + 1)
});
}
List<RiqEntity> typeEvents = EventCaller.GetAllInGameManagerList("nightWalkAgb", new string[] { "type" });
foreach (var typeEvent in typeEvents)
{
if (!platformTypes.ContainsKey(typeEvent.beat))
{
PlatformType type = (PlatformType)typeEvent["type"];
FillType fill = (FillType)typeEvent["fill"];
platformTypes.Add(typeEvent.beat, new TypeEvent
{
fillType = fill,
platformType = type
});
}
}
List<RiqEntity> fishEvents = EventCaller.GetAllInGameManagerList("nightWalkAgb", new string[] { "fish" });
foreach(var fishEvent in fishEvents)
{
fishBeats.Add(fishEvent.beat);
}
foreach (var rollEvent in validRollEvents)
{
rollBeats.Add(rollEvent.beat);
}
}
private void OnDestroy()
{
foreach (var evt in scheduledInputs)
{
evt.Disable();
}
if (!Conductor.instance.isPlaying) hitJumpsPersist = 0;
}
public void ForceEvolve(double beat, float length, int starAmount, int repeatAmount)
{
List<BeatAction.Action> actions = new();
for (int i = 0; i < repeatAmount; i++)
{
actions.Add(new BeatAction.Action(beat + (length * i), delegate
{
starHandler.Evolve(starAmount);
}));
}
BeatAction.New(this, actions);
}
public bool FishOnBeat(double beat)
{
return fishBeats.Contains(beat);
}
public bool RollOnBeat(double beat)
{
return rollBeats.Contains(beat);
}
public int FindHeightUnitsAtBeat(double beat)
{
List<HeightEvent> tempEvents = heightEntityEvents.FindAll(e => e.beat <= beat);
int height = 0;
foreach (var heightEvent in tempEvents)
{
height += heightEvent.value;
}
return height;
}
public bool ShouldNotJumpOnBeat(double beat)
{
List<RiqEntity> heightEvents = EventCaller.GetAllInGameManagerList("nightWalkAgb", new string[] { "noJump" });
return heightEvents.Find(x => beat >= x.beat && beat < x.beat + x.length) != null;
}
public override void OnGameSwitch(double beat)
{
SetCountInBeat(beat);
SetEndValues(beat);
platformHandler.SpawnPlatforms(beat);
}
public override void OnPlay(double beat)
{
SetCountInBeat(beat);
SetEndValues(beat);
platformHandler.SpawnPlatforms(beat);
hitJumpsPersist = 0;
}
public void SetEndValues(double beat)
{
List<RiqEntity> endEvents = EventCaller.GetAllInGameManagerList("nightWalkAgb", new string[] { "end" });
if (endEvents.Count > 0)
{
var allEnds = EventCaller.GetAllInGameManagerList("gameManager", new string[] { "switchGame" });
if (allEnds.Count == 0)
{
endBeat = endEvents[^1].beat;
requiredJumps = endEvents[^1]["minAmount"];
requiredJumpsP = endEvents[^1]["minAmountP"];
}
else
{
allEnds.Sort((x, y) => x.beat.CompareTo(y.beat));
double nextSwitchBeat = double.MaxValue;
foreach (var end in allEnds)
{
if (end.datamodel.Split(2) == "nightWalkAgb") continue;
if (end.beat > beat)
{
nextSwitchBeat = end.beat;
break;
}
}
var tempEvents = endEvents.FindAll(e => e.beat >= beat && e.beat < nextSwitchBeat);
if (tempEvents.Count > 0)
{
endBeat = tempEvents[^1].beat;
requiredJumps = tempEvents[^1]["minAmount"];
requiredJumpsP = tempEvents[^1]["minAmountP"];
}
}
}
}
/*public static void FishSound(double beat)
{
if (GameManager.instance.currentGame == "nightWalkAgb" && instance.platformHandler.PlatformsStopped()) return;
MultiSound.Play(new MultiSound.Sound[]
{
new MultiSound.Sound("nightWalkAgb/fish1", beat - 1),
new MultiSound.Sound("nightWalkAgb/fish2", beat - 0.75),
new MultiSound.Sound("nightWalkAgb/fish3", beat - 0.5),
}, forcePlay: true);
}*/
public static bool IsValidRollCue(RiqEntity entity)
{
List<RiqEntity> allEnds = EventCaller.GetAllInGameManagerList("gameManager", new string[] { "switchGame" });
List<RiqEntity> allRolls = EventCaller.GetAllInGameManagerList("nightWalkAgb", new string[] { "roll" });
if (allRolls.Find(x => x != entity && entity.beat >= x.beat && entity.beat < x.beat + x.length) != null)
{
return false;
}
if (allEnds.Count > 0)
{
List<RiqEntity> tempEnds = new();
foreach (var end in allEnds)
{
if (end.datamodel.Split(2) == "nightWalkAgb")
{
tempEnds.Add(end);
}
}
List<RiqEntity> tempEnds2 = new();
foreach (var end in tempEnds)
{
if (end.beat <= entity.beat) tempEnds2.Add(end);
}
double lastSwitchBeat = double.MinValue;
if (tempEnds2.Count > 0)
{
tempEnds2.Sort((x, y) => x.beat.CompareTo(y.beat));
lastSwitchBeat = tempEnds2[^1].beat;
}
else if (tempEnds.Count > 0)
{
tempEnds.Sort((x, y) => x.beat.CompareTo(y.beat));
lastSwitchBeat = tempEnds[0].beat;
}
double countInBeat = double.MinValue;
float countInLength = 0;
FindCountInBeatAndLength(lastSwitchBeat, ref countInBeat, ref countInLength);
bool isNotOffbeat = entity.beat % 1 == countInBeat % 1;
return entity.beat >= countInBeat + countInLength && entity.beat >= lastSwitchBeat && isNotOffbeat;
}
else
{
double countInBeat = double.MinValue;
float countInLength = 0;
FindCountInBeatAndLength(0, ref countInBeat, ref countInLength);
bool isNotOffbeat = entity.beat % 1 == countInBeat % 1;
return entity.beat >= countInBeat + countInLength && isNotOffbeat;
}
}
public static void FindCountInBeatAndLength(double beat, ref double countInBeat, ref float countInLength)
{
List<RiqEntity> countInEvents = EventCaller.GetAllInGameManagerList("nightWalkAgb", new string[] { "countIn8", "countIn4" });
if (countInEvents.Count > 0)
{
var allEnds = EventCaller.GetAllInGameManagerList("gameManager", new string[] { "switchGame" });
if (allEnds.Count == 0)
{
countInBeat = countInEvents[^1].beat;
countInLength = countInEvents[^1].length;
}
else
{
allEnds.Sort((x, y) => x.beat.CompareTo(y.beat));
double nextSwitchBeat = double.MaxValue;
foreach (var end in allEnds)
{
if (end.datamodel.Split(2) == "nightWalkAgb") continue;
if (end.beat > beat)
{
nextSwitchBeat = end.beat;
break;
}
}
List<RiqEntity> tempEvents = new();
foreach (var countIn in countInEvents)
{
if (countIn.beat < nextSwitchBeat)
{
tempEvents.Add(countIn);
}
}
if (tempEvents.Count > 0)
{
tempEvents.Sort((x, y) => x.beat.CompareTo(y.beat));
countInBeat = tempEvents[tempEvents.Count - 1].beat;
countInLength = tempEvents[tempEvents.Count - 1].length;
}
}
}
}
public static void PlayRollCue(double beat, RiqEntity entity)
{
if (!IsValidRollCue(entity)) return;
Debug.Log("played roll sound");
MultiSound.Play(new MultiSound.Sound[]
{
new MultiSound.Sound("games/nightWalkRvl/highJump1", beat - 1),
new MultiSound.Sound("games/nightWalkRvl/highJump2", beat - 0.75),
new MultiSound.Sound("games/nightWalkRvl/highJump3", beat - 0.5),
new MultiSound.Sound("games/nightWalkRvl/highJump4", beat - 0.25),
new MultiSound.Sound("games/nightWalkRvl/highJump6", beat + 0.25),
}, false, true);
}
public static void WalkingCountIn(double beat, float length)
{
List<MultiSound.Sound> sounds = new();
for (int i = 0; i < length; i++)
{
sounds.Add(new MultiSound.Sound("nightWalkAgb/boxKick", beat + i));
sounds.Add(new MultiSound.Sound("nightWalkAgb/open1", beat + 0.5 + i));
}
MultiSound.Play(sounds.ToArray(), forcePlay: true);
}
public static void FillSound(double beat, FillType fill)
{
if (GameManager.instance.currentGame == "nightWalkAgb" && instance.platformHandler.PlatformsStopped()) return;
double third = 1.0 / 3.0;
switch (fill)
{
case FillType.None:
break;
case FillType.Pattern1:
MultiSound.Play(new MultiSound.Sound[]
{
new MultiSound.Sound("nightWalkAgb/fill1A", beat - (third * 2)),
new MultiSound.Sound("nightWalkAgb/fill1B", beat - 0.5),
new MultiSound.Sound("nightWalkAgb/fill1C", beat - third),
new MultiSound.Sound("nightWalkAgb/fill1D", beat - (third * 0.5)),
}, forcePlay: true);
break;
case FillType.Pattern2:
MultiSound.Play(new MultiSound.Sound[]
{
new MultiSound.Sound("nightWalkAgb/fill2A", beat - (third * 2)),
new MultiSound.Sound("nightWalkAgb/fill2B", beat - 0.5),
new MultiSound.Sound("nightWalkAgb/fill2C", beat - (third * 0.5)),
}, forcePlay: true);
break;
case FillType.Pattern3:
MultiSound.Play(new MultiSound.Sound[]
{
new MultiSound.Sound("nightWalkAgb/fill3A", beat - (third * 2)),
new MultiSound.Sound("nightWalkAgb/fill3B", beat - 0.5),
}, forcePlay: true);
break;
}
}
private void SetCountInBeat(double beat)
{
List<RiqEntity> countInEvents = EventCaller.GetAllInGameManagerList("nightWalkAgb", new string[] { "countIn8", "countIn4" });
if (countInEvents.Count > 0)
{
var allEnds = EventCaller.GetAllInGameManagerList("gameManager", new string[] { "switchGame" });
if (allEnds.Count == 0)
{
countInBeat = countInEvents[^1].beat;
countInLength = countInEvents[^1].length;
}
else
{
allEnds.Sort((x, y) => x.beat.CompareTo(y.beat));
double nextSwitchBeat = double.MaxValue;
foreach (var end in allEnds)
{
if (end.datamodel.Split(2) == "nightWalkAgb") continue;
if (end.beat > beat)
{
nextSwitchBeat = end.beat;
break;
}
}
List<RiqEntity> tempEvents = new();
foreach (var countIn in countInEvents)
{
if (countIn.beat < nextSwitchBeat)
{
tempEvents.Add(countIn);
}
}
if (tempEvents.Count > 0)
{
tempEvents.Sort((x, y) => x.beat.CompareTo(y.beat));
countInBeat = tempEvents[tempEvents.Count - 1].beat;
countInLength = tempEvents[tempEvents.Count - 1].length;
}
}
}
UpdateBalloons(beat);
}
public static bool IsValidCountIn(RiqEntity countInEntity)
{
List<RiqEntity> countInEvents = EventCaller.GetAllInGameManagerList("nightWalkAgb", new string[] { "countIn8", "countIn4" });
if (countInEvents.Count > 0)
{
var allEnds = EventCaller.GetAllInGameManagerList("gameManager", new string[] { "switchGame" });
if (allEnds.Count == 0)
{
return countInEntity == countInEvents[0];
}
else
{
allEnds.Sort((x, y) => x.beat.CompareTo(y.beat));
List<RiqEntity> tempEnds = new();
double beat = double.MinValue;
for (int i = 0; i < allEnds.Count; i++)
{
if (allEnds[i].datamodel.Split(2) == "nightWalkAgb")
{
if (allEnds[i].beat >= countInEntity.beat)
{
tempEnds.Add(allEnds[i]);
}
}
}
if (tempEnds.Count > 0) beat = tempEnds[0].beat;
double nextSwitchBeat = double.MaxValue;
foreach (var end in allEnds)
{
if (end.datamodel.Split(2) == "nightWalkAgb") continue;
if (end.beat > beat)
{
nextSwitchBeat = end.beat;
break;
}
}
List<RiqEntity> tempEvents = new();
foreach (var countIn in countInEvents)
{
if (countIn.beat < nextSwitchBeat)
{
tempEvents.Add(countIn);
}
}
if (tempEvents.Count == 0) return true;
tempEvents.Sort((x, y) => x.beat.CompareTo(y.beat));
return countInEntity == tempEvents[tempEvents.Count - 1];
}
}
return false;
}
private void UpdateBalloons(double beat)
{
if (countInBeat != -1)
{
if (countInLength == 8)
{
BeatAction.New(this, new List<BeatAction.Action>()
{
new BeatAction.Action(countInBeat, delegate { playYan.PopBalloon(0, beat > countInBeat); }),
new BeatAction.Action(countInBeat + 2, delegate { playYan.PopBalloon(1, beat > countInBeat + 2); }),
new BeatAction.Action(countInBeat + 4, delegate { playYan.PopBalloon(2, beat > countInBeat + 4); }),
new BeatAction.Action(countInBeat + 5, delegate { playYan.PopBalloon(3, beat > countInBeat + 5); }),
new BeatAction.Action(countInBeat + 6, delegate { playYan.PopBalloon(4, beat > countInBeat + 6); }),
new BeatAction.Action(countInBeat + 7, delegate { playYan.PopBalloon(5, beat > countInBeat + 7); }),
new BeatAction.Action(countInBeat + 8, delegate { playYan.PopBalloon(6, beat > countInBeat + 8); }),
});
}
else
{
playYan.PopBalloon(0, true);
playYan.PopBalloon(1, true);
BeatAction.New(this, new List<BeatAction.Action>()
{
new BeatAction.Action(countInBeat, delegate { playYan.PopBalloon(2, beat > countInBeat); }),
new BeatAction.Action(countInBeat + 1, delegate { playYan.PopBalloon(3, beat > countInBeat + 1); }),
new BeatAction.Action(countInBeat + 2, delegate { playYan.PopBalloon(4, beat > countInBeat + 2); }),
new BeatAction.Action(countInBeat + 3, delegate { playYan.PopBalloon(5, beat > countInBeat + 3); }),
new BeatAction.Action(countInBeat + 4, delegate { playYan.PopBalloon(6, beat > countInBeat + 4); }),
});
}
}
else
{
playYan.PopAll();
}
}
public static void CountInSound8(double beat)
{
MultiSound.Play(new MultiSound.Sound[]
{
new MultiSound.Sound("count-ins/cowbell", beat),
new MultiSound.Sound("count-ins/cowbell", beat + 2),
new MultiSound.Sound("count-ins/cowbell", beat + 4),
new MultiSound.Sound("count-ins/cowbell", beat + 5),
new MultiSound.Sound("count-ins/cowbell", beat + 6),
new MultiSound.Sound("count-ins/cowbell", beat + 7),
}, false, true);
}
public static void CountInSound4(double beat)
{
MultiSound.Play(new MultiSound.Sound[]
{
new MultiSound.Sound("count-ins/cowbell", beat),
new MultiSound.Sound("count-ins/cowbell", beat + 1),
new MultiSound.Sound("count-ins/cowbell", beat + 2),
new MultiSound.Sound("count-ins/cowbell", beat + 3),
}, false, true);
}
}
}