etc/HeavenStudioPlus
0
0
Fork 0
mirror of https://github.com/RHeavenStudioPlus/HeavenStudioPlus.git synced 2024-11-25 11:05:16 +00:00
Code Issues Projects Releases Packages Wiki Activity

Mass Text Update (#615)

Browse source 
* Air Rally Text Update

* Blue Bear Text Update

* Board Meeting Text Update

* Built To Scale DS Text Update

also changed Air Rally's assetbundle tag from "normal" to "keep"

* Catchy Tune Text Update

also changed some minor wording in Board Meeting and Built To Scale DS

* Cheer Readers Text Update

* The Clappy Trio Text Update

* Coin Toss Text Update

* Crop Stomp Text Update

* DJ School Text Update

* Dog Ninja Text Update

* Double Date Text Update

* Drumming Practice Text Update

* Fan Club Text Update

* Fireworks Text Update

* Second Contact Text Update

* Flipper-Flop Text Update

also fix an error in Catchy Tune

* Fork Lifter Text Update

* Glee Club Text Update

* Karate Man Text Update

also minor updates to other games

* Kitties! Text Update

* Launch Party Text Update

* Lockstep Text Update

* Marching Orders Text Update

* Meat Grinder Text Update

also fixed an error in Second Contact

* Mr. Upbeat Text Update

* Munchy Monk Text Update

* Octopus Machine Text Update

* Pajama Party Text Update

* Quiz Show Text Update

also changed some wording in meat grinder

* Rhythm Rally Text Update

* Rhythm Somen Text Update

that was easy

* Rhythm Tweezers Text Update

* Ringside Text Update

* Rockers Text Update

this sucked

* Samurai Slice DS Text Update

* See Saw Text Update

* Sneaky Spirits Text Update

* Spaceball Text Update

* Space Dance Text Update

* Space Soccer Text Update

* Splashdown Text Update

* Tambourine Text Update

* Tap Trial Text Update

* Tap Troupe Text Update

* The Dazzles Text Update

* Toss Boys Text Update

* Tram & Pauline Text Update

also added translation for Fireworks

* Tunnel Text Update

* Wizard's Waltz Text Update

* Working Dough Text Update

* fix compiler errors

* fix editor offset bug(?)

* fix missing param in second contact

* Ball Redispense text

* remove space soccer swing

* Trick on the Class Text Update

* Non-Game Text Update

* fix pre-function sorting

* camera shake ease

* remove a bunch of prints

* rhythm tweezers bug fix

* Update Credits.txt

* ssds nop samurai bop

* swap order of shake properties

* Update FirstContact.cs

---------

Co-authored-by: minenice55 <star.elementa@gmail.com>
This commit is contained in:
Zeo 2024-01-14 20:04:10 -06:00 committed by GitHub
parent 4fa9294fdd
commit 3a4279ce5e
71 changed files with 1329 additions and 1403 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
Assets/Resources/Credits.txt
View file

@ -16,6 +16,10 @@
-<indent=5%>Rapandrasmus</indent>
-<indent=5%>AstrlJelly</indent>
-<indent=5%>Maddy / saladplainzone</indent>
-<indent=5%>NoahAmp</indent>
-<indent=5%>Bhaos</indent>
-<indent=5%>Raffy</indent>
-<indent=5%>Thinedave</indent>
<align="center"><b>Artwork</b></align>
-<indent=5%>Ko Takeuchi <alpha=#88>(Original <i>Rhythm Heaven</i> Assets)<alpha=#FF></indent>
@ -45,10 +49,20 @@
-<indent=5%>o207n</indent>
-<indent=5%>TheCloudMonkey</indent>
-<indent=5%>flaticon.com</indent>
-<indent=5%>Untitled</indent>
-<indent=5%>Rainbo</indent>
-<indent=5%>Butternnife</indent>
-<indent=5%>Minesweeper95</indent>
-<indent=5%>mizuno</indent>
-<indent=5%>Flowercardiganwillow</indent>
-<indent=5%>vincells</indent>
<align="center"><b>Music</b></align>
-<indent=5%>Jellirby <alpha=#88>(Opening)<alpha=#FF></indent>
-<indent=5%>SushiiZ <alpha=#88>(Title Screen, Results, Epilogue)<alpha=#FF></indent>
-<indent=5%>Kievit <alpha=#88>(SFX Ripping)<alpha=#FF></indent>
-<indent=5%>Synthnerd</indent>
-<indent=5%>Wookywok</indent>
<align="center"><b>Font</b></align>
-<indent=5%>Tailx <alpha=#88>(Kurokane Modified)<alpha=#FF></indent>

17
Assets/Resources/Models/Games/RhythmRally/materials/field/stand.png.meta
View file

@ -3,7 +3,7 @@ guid: 0f640706f6e1ac240aeaef7d039c8f6a
TextureImporter:
internalIDToNameTable: []
externalObjects: {}
serializedVersion: 11
serializedVersion: 12
mipmaps:
mipMapMode: 0
enableMipMap: 0
@ -24,6 +24,7 @@ TextureImporter:
streamingMipmaps: 0
streamingMipmapsPriority: 0
vTOnly: 0
ignoreMasterTextureLimit: 0
grayScaleToAlpha: 0
generateCubemap: 6
cubemapConvolution: 0
@ -62,6 +63,7 @@ TextureImporter:
textureFormatSet: 0
ignorePngGamma: 0
applyGammaDecoding: 0
cookieLightType: 1
platformSettings:
- serializedVersion: 3
buildTarget: DefaultTexturePlatform
@ -99,6 +101,18 @@ TextureImporter:
overridden: 0
androidETC2FallbackOverride: 0
forceMaximumCompressionQuality_BC6H_BC7: 0
- serializedVersion: 3
buildTarget: Server
maxTextureSize: 2048
resizeAlgorithm: 0
textureFormat: -1
textureCompression: 1
compressionQuality: 50
crunchedCompression: 0
allowsAlphaSplitting: 0
overridden: 0
androidETC2FallbackOverride: 0
forceMaximumCompressionQuality_BC6H_BC7: 0
spriteSheet:
serializedVersion: 2
sprites: []
@ -112,6 +126,7 @@ TextureImporter:
edges: []
weights: []
secondaryTextures: []
nameFileIdTable: {}
spritePackingTag:
pSDRemoveMatte: 0
pSDShowRemoveMatteOption: 0

1
Assets/Scripts/Common/MemRenderer.cs
View file

@ -17,7 +17,6 @@ public class MemRenderer : MonoBehaviour
public void ChangeMem()
{
Debug.Log("ChangeMem");
Destroy(_instance);
_instance = Instantiate(prefabs[UnityEngine.Random.Range(0, prefabs.Length)], transform);
}

13
Assets/Scripts/GameCamera.cs
View file

@ -175,7 +175,7 @@ namespace HeavenStudio
UpdateCameraTranslate();
UpdateCameraRotate();
SetShakeIntensity();
UpdateShakeIntensity();
UpdateCameraColor();
}
@ -183,7 +183,7 @@ namespace HeavenStudio
{
UpdateCameraTranslate();
UpdateCameraRotate();
SetShakeIntensity();
UpdateShakeIntensity();
UpdateCameraColor();
}
@ -323,19 +323,20 @@ namespace HeavenStudio
}
}
private void SetShakeIntensity()
private void UpdateShakeIntensity()
{
foreach (var e in shakeEvents)
{
float prog = Conductor.instance.GetPositionFromBeat(e.beat, e.length);
float fac = Mathf.Cos(Time.time * 80f) * 0.5f;
if (prog >= 0f)
{
float fac = Mathf.Cos(Time.time * 80f) * 0.5f;
ShakeResult = new Vector3(fac * e["valA"], fac * e["valB"]);
Util.EasingFunction.Function func = Util.EasingFunction.GetEasingFunction((Util.EasingFunction.Ease) e["ease"]);
ShakeResult = new Vector3(fac * func(e["easedA"], e["valA"], Mathf.Min(prog, 1f)), fac * func(e["easedB"], e["valB"], Mathf.Min(prog, 1f)));
}
if (prog > 1f)
{
ShakeResult = new Vector3(0, 0);
ShakeResult = new Vector3(fac * e["valA"], fac * e["valB"]);
}
}
}

50
Assets/Scripts/GameManager.cs
View file

@ -69,7 +69,7 @@ namespace HeavenStudio
bool AudioLoadDone;
bool ChartLoadError;
List<double> eventBeats, tempoBeats, volumeBeats, sectionBeats;
List<double> eventBeats, preSequenceBeats, tempoBeats, volumeBeats, sectionBeats;
List<RiqEntity> allGameSwitches;
public event Action<double> onBeatChanged;
@ -455,27 +455,22 @@ namespace HeavenStudio
{
if (currentPreSequence < Beatmap.Entities.Count && currentPreSequence >= 0)
{
List<RiqEntity> entitiesAtSameBeat = ListPool<RiqEntity>.Get();
RiqEntity seekEntity = Beatmap.Entities[currentPreSequence];
if (start >= preSequenceBeats[currentPreSequence])
{
List<RiqEntity> entitiesInRange = ListPool<RiqEntity>.Get();
foreach (RiqEntity entity in Beatmap.Entities)
{
if (entity.beat == seekEntity.beat)
string[] entityDatamodel = entity.datamodel.Split('/');
double seekTime = eventCaller.GetGameAction(entityDatamodel[0], entityDatamodel[1]).preFunctionLength;
if (entity.beat - seekTime == preSequenceBeats[currentPreSequence])
{
entitiesAtSameBeat.Add(entity);
entitiesInRange.Add(entity);
}
}
SortEventsByPriority(entitiesAtSameBeat);
SortEventsByPriority(entitiesInRange);
string[] seekEntityDatamodel = seekEntity.datamodel.Split('/');
float seekTime = eventCaller.GetGameAction(seekEntityDatamodel[0], seekEntityDatamodel[1]).preFunctionLength;
if (start + seekTime >= eventBeats[currentPreSequence])
foreach (RiqEntity entity in entitiesInRange)
{
foreach (RiqEntity entity in entitiesAtSameBeat)
{
currentPreSequence++;
string gameName = entity.datamodel.Split('/')[0];
var inf = GetGameInfo(gameName);
if (inf != null && inf.usesAssetBundle && inf.AssetsLoaded && !inf.SequencesPreloaded)
@ -484,9 +479,10 @@ namespace HeavenStudio
PreloadGameSequences(gameName);
}
eventCaller.CallPreEvent(entity);
currentPreSequence++;
}
ListPool<RiqEntity>.Release(entitiesInRange);
}
ListPool<RiqEntity>.Release(entitiesAtSameBeat);
}
}
@ -577,13 +573,13 @@ namespace HeavenStudio
{
if (clampedBeat >= eventBeats[currentEvent])
{
List<RiqEntity> entitiesAtSameBeat = ListPool<RiqEntity>.Get();
List<RiqEntity> entitiesInRange = ListPool<RiqEntity>.Get();
List<RiqEntity> fxEntities = ListPool<RiqEntity>.Get();
// allows for multiple events on the same beat to be executed on the same frame, so no more 1-frame delay
using (PooledObject<List<RiqEntity>> pool = ListPool<RiqEntity>.Get(out List<RiqEntity> currentBeatEntities))
{
currentBeatEntities = Beatmap.Entities.FindAll(c => c.beat == Beatmap.Entities[currentEvent].beat);
currentBeatEntities = Beatmap.Entities.FindAll(c => c.beat == eventBeats[currentEvent]);
foreach (RiqEntity entity in currentBeatEntities)
{
if (EventCaller.FXOnlyGames().Contains(eventCaller.GetMinigame(entity.datamodel.Split('/')[0])))
@ -592,13 +588,13 @@ namespace HeavenStudio
}
else
{
entitiesAtSameBeat.Add(entity);
entitiesInRange.Add(entity);
}
}
}
SortEventsByPriority(fxEntities);
SortEventsByPriority(entitiesAtSameBeat);
SortEventsByPriority(entitiesInRange);
// FX entities should ALWAYS execute before gameplay entities
foreach (RiqEntity entity in fxEntities)
@ -607,7 +603,7 @@ namespace HeavenStudio
currentEvent++;
}
foreach (RiqEntity entity in entitiesAtSameBeat)
foreach (RiqEntity entity in entitiesInRange)
{
// if game isn't loaded, preload game so whatever event that would be called will still run outside if needed
if (entity.datamodel.Split('/')[0] != currentGame)
@ -623,7 +619,7 @@ namespace HeavenStudio
currentEvent++;
}
ListPool<RiqEntity>.Release(entitiesAtSameBeat);
ListPool<RiqEntity>.Release(entitiesInRange);
ListPool<RiqEntity>.Release(fxEntities);
}
}
@ -893,6 +889,15 @@ namespace HeavenStudio
sectionBeats = Beatmap.SectionMarkers.Select(c => c.beat).ToList();
allGameSwitches = EventCaller.GetAllInGameManagerList("gameManager", new string[] { "switchGame" });
preSequenceBeats = new List<double>();
foreach (RiqEntity entity in Beatmap.Entities)
{
string[] seekEntityDatamodel = entity.datamodel.Split('/');
double seekTime = eventCaller.GetGameAction(seekEntityDatamodel[0], seekEntityDatamodel[1]).preFunctionLength;
preSequenceBeats.Add(entity.beat - seekTime);
}
preSequenceBeats.Sort();
}
void SortEventsByPriority(List<RiqEntity> entities)
@ -909,7 +914,6 @@ namespace HeavenStudio
return yAction.priority.CompareTo(xAction.priority);
});
}
public static double GetClosestInList(List<double> list, double compareTo)

82
Assets/Scripts/Games/AirRally/AirRally.cs
View file

@ -27,8 +27,8 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 6f,
parameters = new List<Param>()
{
new Param("toggle", true, "Count", "Make Forthington Count"),
new Param("toggle2", false, "Alternate Voiceline")
new Param("toggle", true, "Count", "Toggle if Forthington should count after the event."),
new Param("toggle2", false, "Alternate Voice Line", "Toggle if Forthington should use an alternate voice line.")
},
preFunctionLength = 1
},
@ -37,8 +37,8 @@ namespace HeavenStudio.Games.Loaders
function = delegate { AirRally.instance.SetDistance(e.currentEntity.beat, e.currentEntity["type"], e.currentEntity["ease"]); },
parameters = new List<Param>()
{
new Param("type", AirRally.DistanceSound.close, "Type", "How far is Forthington?"),
new Param("ease", EasingFunction.Ease.EaseOutQuad, "Ease")
new Param("type", AirRally.DistanceSound.close, "Type", "Set Forthington's distance."),
new Param("ease", EasingFunction.Ease.EaseOutQuad, "Ease", "Set the easing of the action.")
}
},
new GameAction("catch", "Catch Birdie"),
@ -52,10 +52,10 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 2f,
parameters = new List<Param>()
{
new Param("ease", EasingFunction.Ease.EaseOutQuad, "Ease")
new Param("ease", EasingFunction.Ease.EaseOutQuad, "Ease", "Set the easing of the action.")
}
},
new GameAction("forward", "Animals Look Forward")
new GameAction("forward", "Look Forward")
{
function = delegate
{
@ -63,7 +63,7 @@ namespace HeavenStudio.Games.Loaders
},
parameters = new List<Param>()
{
new Param("reset", false, "Reset", "Reset to Idle pose?")
new Param("reset", false, "Reset", "Toggle this to reset the animals to their idle pose.")
}
},
new GameAction("4beat", "4 Beat Count-In")
@ -98,7 +98,7 @@ namespace HeavenStudio.Games.Loaders
preFunction = delegate { AirRally.ForthVoice(e.currentEntity.beat, e.currentEntity["type"]); },
parameters = new List<Param>()
{
new Param("type", AirRally.CountSound.one, "Type", "The number Forthington will say"),
new Param("type", AirRally.CountSound.one, "Type", "Set the number Forthington will say."),
},
},
new GameAction("spawnBird", "Spawn Birds")
@ -110,14 +110,14 @@ namespace HeavenStudio.Games.Loaders
},
parameters = new List<Param>()
{
new Param("type", AirRally.BirdType.Pterosaurs, "Type"),
new Param("xSpeed", new EntityTypes.Float(-10, 10, 1), "X Speed Multiplier"),
new Param("zSpeed", new EntityTypes.Float(-10, 10, 1), "Z Speed Multiplier"),
new Param("startZ", new EntityTypes.Float(0, 1000, 200), "Z Start Position"),
new Param("invert", false, "Invert X Direction")
new Param("type", AirRally.BirdType.Pterosaurs, "Type", "Choose the type of bird to spawn."),
new Param("xSpeed", new EntityTypes.Float(-10, 10, 1), "X Speed", "Change the horizontal speed of the birds."),
new Param("zSpeed", new EntityTypes.Float(-10, 10, 1), "Z Speed", "Change how fast the birds approach the camera."),
new Param("startZ", new EntityTypes.Float(0, 1000, 200), "Z Start Position", "Change how close to the camera the birds spawn."),
new Param("invert", false, "Flip Horizontally", "Toggle if the birds should fly left to right.")
}
},
new GameAction("rainbow", "Rainbow")
new GameAction("rainbow", "Spawn Rainbow")
{
function = delegate
{
@ -125,11 +125,11 @@ namespace HeavenStudio.Games.Loaders
},
parameters = new List<Param>()
{
new Param("start", new EntityTypes.Float(0, 500, 100), "Start Position"),
new Param("speed", new EntityTypes.Float(-10, 10, 1), "Speed Multiplier")
new Param("start", new EntityTypes.Float(0, 500, 100), "Start Position", "Change how close to the camera the rainbow spawns."),
new Param("speed", new EntityTypes.Float(-10, 10, 1), "Speed", "Change how fast the rainbow approaches the camera.")
}
},
new GameAction("day", "Day/Night Cycle")
new GameAction("day", "Time Of Day")
{
function = delegate
{
@ -140,9 +140,9 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("start", AirRally.DayNightCycle.Day, "Start Time"),
new Param("end", AirRally.DayNightCycle.Noon, "End Time"),
new Param("ease", EasingFunction.Ease.Linear, "Ease")
new Param("start", AirRally.DayNightCycle.Day, "Start Time", "Set the time of day for the start of the event."),
new Param("end", AirRally.DayNightCycle.Noon, "End Time", "Set the time of day for the end of the event."),
new Param("ease", EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.")
}
},
new GameAction("cloud", "Cloud Density")
@ -155,12 +155,12 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("main", new EntityTypes.Integer(0, 300, 30), "Main Clouds", "How many clouds per second?"),
new Param("side", new EntityTypes.Integer(0, 100, 10), "Side Clouds", "How many clouds per second?"),
new Param("top", new EntityTypes.Integer(0, 100, 0), "Top Clouds", "How many clouds per second?"),
new Param("speed", new EntityTypes.Float(-10, 10, 1), "Speed Multiplier"),
new Param("endSpeed", new EntityTypes.Float(-10, 10, 1), "End Speed Multiplier"),
new Param("ease", EasingFunction.Ease.Linear, "Ease")
new Param("main", new EntityTypes.Integer(0, 300, 30), "Main Clouds", "Set how many clouds per second should be spawned in the center."),
new Param("side", new EntityTypes.Integer(0, 100, 10), "Side Clouds", "Set how many clouds per second should be spawned on the sides."),
new Param("top", new EntityTypes.Integer(0, 100, 0), "Top Clouds", "Set how many clouds per second should be spawned on the top."),
new Param("speed", new EntityTypes.Float(-10, 10, 1), "Start Speed", "Change how fast the clouds are moving at the start of the event."),
new Param("endSpeed", new EntityTypes.Float(-10, 10, 1), "End Speed", "Change how fast the clouds are moving at the end of the event."),
new Param("ease", EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.")
}
},
new GameAction("snowflake", "Snowflake Density")
@ -173,10 +173,10 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("cps", new EntityTypes.Integer(0, 200, 0), "Snowflakes per Second"),
new Param("speed", new EntityTypes.Float(-10, 10, 1), "Speed Multiplier"),
new Param("endSpeed", new EntityTypes.Float(-10, 10, 1), "End Speed Multiplier"),
new Param("ease", EasingFunction.Ease.Linear, "Ease")
new Param("cps", new EntityTypes.Integer(0, 200, 0), "Snowflakes Amount", "Set how many snowflakes should be spawned per second."),
new Param("speed", new EntityTypes.Float(-10, 10, 1), "Start Speed", "Change fow fast the snowflakes are moving at the start of the event."),
new Param("endSpeed", new EntityTypes.Float(-10, 10, 1), "End Speed", "Change how fast the snowflakes are moving at the end of the event."),
new Param("ease", EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.")
}
},
new GameAction("tree", "Trees")
@ -189,18 +189,18 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("enable", true, "Enable", "", new List<Param.CollapseParam>()
new Param("enable", true, "Enable", "Toggle if the trees are enabled.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (bool)x, new string[] { "main", "side", "speed", "endSpeed", "ease" })
}),
new Param("main", new EntityTypes.Integer(0, 300, 50), "Main Trees", "How many trees per second?"),
new Param("side", new EntityTypes.Integer(0, 100, 30), "Side Trees", "How many trees per second?"),
new Param("speed", new EntityTypes.Float(-10, 10, 1), "Speed Multiplier"),
new Param("endSpeed", new EntityTypes.Float(-10, 10, 1), "End Speed Multiplier"),
new Param("ease", EasingFunction.Ease.Linear, "Ease")
new Param("main", new EntityTypes.Integer(0, 300, 50), "Main Trees", "Set how many trees per second should be spawned in the center."),
new Param("side", new EntityTypes.Integer(0, 100, 30), "Side Trees", "Set how many trees per second should be spawned on the sides."),
new Param("speed", new EntityTypes.Float(-10, 10, 1), "Start Speed", "Change how fast the trees are moving at the start of the event."),
new Param("endSpeed", new EntityTypes.Float(-10, 10, 1), "End Speed", "Change how fast the trees are moving at the end of the event."),
new Param("ease", EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.")
}
},
new GameAction("islandSpeed", "Islands Speed")
new GameAction("islandSpeed", "Island Speed")
{
function = delegate
{
@ -210,9 +210,9 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("speed", new EntityTypes.Float(-10, 10, 1), "Speed"),
new Param("endSpeed", new EntityTypes.Float(-10, 10, 1), "End Speed"),
new Param("ease", EasingFunction.Ease.Linear, "Ease")
new Param("speed", new EntityTypes.Float(-10, 10, 1), "Start Speed", "Change how fast the islands are moving at the start of the event."),
new Param("endSpeed", new EntityTypes.Float(-10, 10, 1), "End Speed", "Change how fast the islands are moving at the end of the event."),
new Param("ease", EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.")
}
},
new GameAction("silence", "Silence")
@ -221,7 +221,7 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
}
},
new List<string>() { "rvl", "normal" },
new List<string>() { "rvl", "keep" },
"rvlbadminton", "en",
new List<string>() { "en" }
);

30
Assets/Scripts/Games/BlueBear/BlueBear.cs
View file

@ -22,8 +22,8 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 3,
parameters = new()
{
new("long", false, "Mouth Hold"),
new("open", true, "Should Open Mouth")
new("long", false, "Mouth Hold", "Toggle if Beary should keep his mouth and neck extended after catching the treat."),
new("open", true, "Open Mouth", "Toggle if Beary should open his mouth in preparation for the treat.")
}
},
new GameAction("cake", "Cake")
@ -33,18 +33,22 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 4,
parameters = new()
{
new("long", false, "Mouth Hold"),
new("open", true, "Should Open Mouth")
new("long", false, "Mouth Hold", "Toggle if Beary should keep his mouth and neck extended after catching the treat."),
new("open", true, "Open Mouth", "Toggle if Beary should open his mouth in preparation for the treat.")
}
},
new GameAction("stretchEmotion", "Emotion")
{
function = delegate { var e = eventCaller.currentEntity; if (BlueBear.IsInstantEmotion(e["type"])) BlueBear.instance.SetEmotion(e.beat, e["type"]); },
function = delegate { var e = eventCaller.currentEntity; if (e["instant"] || e["type"] == (int)BlueBear.EmotionStretchType.NoEmotion) BlueBear.instance.SetEmotion(e.beat, e["type"]); },
defaultLength = 4,
resizable = true,
parameters = new List<Param>()
{
new Param("type", BlueBear.EmotionStretchType.NoEmotion, "Emotion", "Which emotion should the blue bear use?"),
new Param("type", BlueBear.EmotionStretchType.NoEmotion, "Emotion", "Set the emotion animation Beary should play.", new()
{
new((x, _) => (int)x != (int)BlueBear.EmotionStretchType.NoEmotion, new string[] { "instant" })
}),
new Param("instant", false, "Instant", "Toggle if the emotion should jump to it's end state. Making \"LookUp\" instant will cause Beary to keep his head down."),
}
},
new GameAction("wind", "Wind")
@ -62,25 +66,25 @@ namespace HeavenStudio.Games.Loaders
function = delegate { BlueBear.instance.OpenMouth(); },
defaultLength = 0.5f
},
new GameAction("story", "Story")
new GameAction("story", "Memory Drawing")
{
defaultLength = 4,
parameters = new List<Param>()
{
new Param("story", BlueBear.StoryType.Date, "Story"),
new Param("enter", true, "Enter")
new Param("story", BlueBear.StoryType.Date, "Memory", "Set the memory that should appear."),
new Param("enter", true, "Enter", "Toggle if the memory should enter or exit the scene.")
},
resizable = true
},
new GameAction("crumb", "Set Crumb Threshold")
new GameAction("crumb", "Set Crumb Thresholds")
{
function = delegate { var e = eventCaller.currentEntity; BlueBear.instance.SetCrumbThreshold(e["right"], e["left"], e["reset"]); },
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("right", new EntityTypes.Integer(0, 500, 15), "Right Crumb", "How many treats should the bear eat before the right crumb can appear on his face?"),
new Param("left", new EntityTypes.Integer(0, 500, 30), "Left Crumb", "How many treats should the bear eat before the left crumb can appear on his face?"),
new Param("reset", false, "Reset Treats Eaten", "Should the numbers of treats eaten be reset?")
new Param("right", new EntityTypes.Integer(0, 500, 15), "Right Crumb", "Set how many treats Beary needs to eat for the right crumb to appear."),
new Param("left", new EntityTypes.Integer(0, 500, 30), "Left Crumb", "Set how many treats Beary needs to eat for the left crumb to appear."),
new Param("reset", false, "Reset Treats Eaten", "Toggle if the current amount of treats eaten (and crumbs) should be reset.")
}
}
},

28
Assets/Scripts/Games/BoardMeeting/BoardMeeting.cs
View file

@ -15,6 +15,16 @@ namespace HeavenStudio.Games.Loaders
{
return new Minigame("boardMeeting", "Board Meeting", "d37912", false, false, new List<GameAction>()
{
new GameAction("bop", "Bop")
{
function = delegate { var e = eventCaller.currentEntity; BoardMeeting.instance.Bop(e.beat, e.length, e["bop"], e["auto"]); },
resizable = true,
parameters = new List<Param>()
{
new Param("bop", true, "Bop", "Toggle if the pigs & assistant should bop for the duration of this event."),
new Param("auto", false, "Bop (Auto)", "Toggle if the pigs & assistant should automatically bop until another Bop event is reached.")
}
},
new GameAction("prepare", "Prepare")
{
function = delegate { BoardMeeting.instance.Prepare(); }
@ -30,8 +40,8 @@ namespace HeavenStudio.Games.Loaders
function = delegate {var e = eventCaller.currentEntity; BoardMeeting.instance.Spin(e["start"], e["end"]); },
parameters = new List<Param>()
{
new Param("start", new EntityTypes.Integer(1, 6, 1), "Starting Pig", "Which pig from the far left (1) or far right (4) should be the first to spin?"),
new Param("end", new EntityTypes.Integer(1, 6, 4), "Ending Pig", "Which pig from the far left (1) or far right (4) should be the last to spin?")
new Param("start", new EntityTypes.Integer(1, 6, 1), "Starting Pig", "Choose the leftmost pig in the range to start spinning."),
new Param("end", new EntityTypes.Integer(1, 6, 4), "Ending Pig", "Choose the rightmost pig in the range to start spinning.")
},
priority = 2
},
@ -46,23 +56,13 @@ namespace HeavenStudio.Games.Loaders
function = delegate { var e = eventCaller.currentEntity; BoardMeeting.instance.AssistantStop(e.beat); },
defaultLength = 3f
},
new GameAction("bop", "Bop")
{
function = delegate { var e = eventCaller.currentEntity; BoardMeeting.instance.Bop(e.beat, e.length, e["bop"], e["auto"]); },
resizable = true,
parameters = new List<Param>()
{
new Param("bop", true, "Bop", "Should the executives and assistant bop?"),
new Param("auto", false, "Bop (Auto)", "Should the executives and assistant auto bop?")
}
},
new GameAction("changeCount", "Change Executives")
new GameAction("changeCount", "Change Pig Number")
{
function = delegate { BoardMeeting.instance.ChangeExecutiveCount(eventCaller.currentEntity["amount"]); },
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("amount", new EntityTypes.Integer(3, 5, 4), "Amount", "How many executives will there be?")
new Param("amount", new EntityTypes.Integer(3, 5, 4), "Pigs", "Set how many pigs there will be. The player is always the rightmost pig.")
}
}
},

26
Assets/Scripts/Games/BuiltToScaleDS/BuiltToScaleDS.cs
View file

@ -22,16 +22,16 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("silent", false, "Mute Audio", "Whether the piano notes should be muted or not.", new List<Param.CollapseParam>()
new Param("silent", false, "Mute Notes", "Toggle if the piano notes in this event should be muted.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => !(bool)x, new string[] { "note1", "note2", "note3", "note4", "note5", "note6"})
}),
new Param("note1", new EntityTypes.Integer(-24, 24, 0), "1st note", "The number of semitones up or down this note should be pitched"),
new Param("note2", new EntityTypes.Integer(-24, 24, 2), "2nd note", "The number of semitones up or down this note should be pitched"),
new Param("note3", new EntityTypes.Integer(-24, 24, 4), "3rd note", "The number of semitones up or down this note should be pitched"),
new Param("note4", new EntityTypes.Integer(-24, 24, 5), "4th note", "The number of semitones up or down this note should be pitched"),
new Param("note5", new EntityTypes.Integer(-24, 24, 7), "5th note", "The number of semitones up or down this note should be pitched"),
new Param("note6", new EntityTypes.Integer(-24, 24, 12), "6th note", "The number of semitones up or down this note should be pitched (This plays together with the 5th note)"),
new Param("note1", new EntityTypes.Integer(-24, 24, 0), "1st note", "Set the number of semitones up or down this note should be pitched."),
new Param("note2", new EntityTypes.Integer(-24, 24, 2), "2nd note", "Set the number of semitones up or down this note should be pitched."),
new Param("note3", new EntityTypes.Integer(-24, 24, 4), "3rd note", "Set the number of semitones up or down this note should be pitched."),
new Param("note4", new EntityTypes.Integer(-24, 24, 5), "4th note", "Set the number of semitones up or down this note should be pitched."),
new Param("note5", new EntityTypes.Integer(-24, 24, 7), "5th note", "Set the number of semitones up or down this note should be pitched. This note plays together with the 6th note."),
new Param("note6", new EntityTypes.Integer(-24, 24, 12), "6th note", "Set the number of semitones up or down this note should be pitched. This note plays together with the 5th note."),
}
},
new GameAction("play piano", "Play Note")
@ -40,7 +40,7 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("type", new EntityTypes.Integer(-24, 24, 0), "Semitones", "The number of semitones up or down this note should be pitched")
new Param("type", new EntityTypes.Integer(-24, 24, 0), "Semitones", "Set the number of semitones up or down this note should be pitched.")
},
},
new GameAction("color", "Color Palette")
@ -49,9 +49,9 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("object", Color.white, "Object Color"),
new Param("shooter", Color.white, "Shooter Color"),
new Param("bg", new Color(0, 1, 0, 1), "Environment Color")
new Param("object", Color.white, "Widget Color", "Choose the color of the widgets & rods."),
new Param("shooter", Color.white, "Paddle Color", "Choose the color of the launch paddle."),
new Param("bg", new Color(0, 1, 0, 1), "Environment Color", "Choose the color of the environment.")
}
},
new GameAction("lights", "Lights")
@ -61,8 +61,8 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("auto", true, "Lights (Auto)", "Should the lights auto light?"),
new Param("light", false, "Lights", "Should the lights light?")
new Param("light", false, "Lights", "Toggle if the lights should activate for the duration of this event."),
new Param("auto", true, "Lights (Auto)", "Toggle if the lights should automatically activate until the another Lights event is reached.")
}
}
}, new List<string>() { "ntr", "normal" }, "ntrassembly", "en", new List<string>() { });

34
Assets/Scripts/Games/CatchyTune/CatchyTune.cs
View file

@ -15,17 +15,28 @@ namespace HeavenStudio.Games.Loaders
{
return new Minigame("catchyTune", "Catchy Tune", "f2f2f2", "ff376c", "f2f2f2", false, false, new List<GameAction>()
{
new GameAction("bop", "Bop")
{
function = delegate {var e = eventCaller.currentEntity; CatchyTune.instance.Bop(e.beat, e.length, e["bop"], e["bopAuto"]); },
resizable = true,
parameters = new List<Param>()
{
new Param("bop", CatchyTune.WhoBops.Both, "Bop", "Set the character(s) to bop for the duration of this event."),
new Param("bopAuto", CatchyTune.WhoBops.None, "Bop (Auto)", "Set the character(s) to automatically bop until another Bop event is reached."),
},
},
new GameAction("orange", "Orange")
{
defaultLength = 4f,
parameters = new List<Param>()
{
new Param("side", CatchyTune.Side.Left, "Side", "The side the orange falls down"),
new Param("smile", false, "Smile", "If the characters smile with the heart message after catching", new List<Param.CollapseParam>()
new Param("side", CatchyTune.Side.Left, "Side", "Choose the side the orange falls down."),
new Param("smile", false, "Smile", "Toggle if Plalin and Alalin should smile after catching.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (bool)x, new string[] { "endSmile" })
}),
new Param("endSmile", new EntityTypes.Float(2, 100, 2), "End Smile Beat", "How many beats after the catch should the smile end?")
new Param("endSmile", new EntityTypes.Float(2, 100, 2), "Smile Length", "Choose how long the smile should last after the catch.")
},
preFunction = delegate {var e = eventCaller.currentEntity; CatchyTune.PreDropFruit(e.beat, e["side"], e["smile"], false, e["endSmile"]); },
},
@ -35,25 +46,14 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 8f,
parameters = new List<Param>()
{
new Param("side", CatchyTune.Side.Left, "Side", "The side the pineapple falls down"),
new Param("smile", false, "Smile", "If the characters smile with the heart message after catching", new List<Param.CollapseParam>()
new Param("side", CatchyTune.Side.Left, "Side", "Choose the side the pineapple falls down."),
new Param("smile", false, "Smile", "Toggle if Plalin and Alalin should smile after catching.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (bool)x, new string[] { "endSmile" })
}),
new Param("endSmile", new EntityTypes.Float(2, 100, 2), "End Smile Beat", "How many beats after the catch should the smile end?")
new Param("endSmile", new EntityTypes.Float(2, 100, 2), "Smile Length", "Choose how long the smile should last after the catch.")
},
preFunction = delegate {var e = eventCaller.currentEntity; CatchyTune.PreDropFruit(e.beat, e["side"], e["smile"], true, e["endSmile"]); },
},
new GameAction("bop", "Bop")
{
function = delegate {var e = eventCaller.currentEntity; CatchyTune.instance.Bop(e.beat, e.length, e["bop"], e["bopAuto"]); },
resizable = true,
parameters = new List<Param>()
{
new Param("bop", CatchyTune.WhoBops.Both, "Bop", "Should Plalin and Alalin bop?"),
new Param("bopAuto", CatchyTune.WhoBops.None, "Bop", "Should Plalin and Alalin auto bop?"),
},
}
},
new List<string>() { "ctr", "normal" },

48
Assets/Scripts/Games/CheerReaders/CheerReaders.cs
View file

@ -20,13 +20,23 @@ namespace HeavenStudio.Games.Loaders
{
return new Minigame("cheerReaders", "Cheer Readers", "ffffde", false, false, new List<GameAction>()
{
new GameAction("bop", "Bop")
{
function = delegate {var e = eventCaller.currentEntity; CheerReaders.instance.BopToggle(e.beat, e.length, e["toggle"], e["toggle2"]); },
resizable = true,
parameters = new List<Param>()
{
new Param("toggle", true, "Bop", "Toggle if the girls should bop for the duration of this event."),
new Param("toggle2", false, "Bop (Auto)", "Toggle if the girls should automatically bop until another Bop event is reached.")
}
},
new GameAction("oneTwoThree", "One! Two! Three!")
{
function = delegate {var e = eventCaller.currentEntity; CheerReaders.instance.OneTwoThree(e.beat, e["solo"]); CheerReaders.instance.SetIsDoingCue(e.beat, e.length);},
defaultLength = 3f,
parameters = new List<Param>()
{
new Param("solo", CheerReaders.WhoSpeaks.Both, "Who Speaks", "Who should say the voice line?")
new Param("solo", CheerReaders.WhoSpeaks.Both, "Speaker", "Choose who says the voice line.")
}
},
new GameAction("itsUpToYou", "It's Up To You!")
@ -35,7 +45,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 3f,
parameters = new List<Param>()
{
new Param("solo", CheerReaders.WhoSpeaks.Both, "Who Speaks", "Who should say the voice line?")
new Param("solo", CheerReaders.WhoSpeaks.Both, "Speaker", "Choose who says the voice line.")
}
},
new GameAction("letsGoReadABunchaBooks", "Let's Go Read A Buncha Books!")
@ -44,7 +54,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 3f,
parameters = new List<Param>()
{
new Param("solo", CheerReaders.WhoSpeaks.Both, "Who Speaks", "Who should say the voice line?")
new Param("solo", CheerReaders.WhoSpeaks.Both, "Speaker", "Choose who says the voice line.")
}
},
new GameAction("rahRahSisBoomBaBoom", "Rah-Rah Sis Boom Bah-BOOM!")
@ -53,8 +63,8 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 4f,
parameters = new List<Param>()
{
new Param("solo", CheerReaders.WhoSpeaks.Both, "Who Speaks", "Who should say the voice line?"),
new Param("consecutive", false, "Consecutive", "Is this cue using the alternate consecutive version?")
new Param("solo", CheerReaders.WhoSpeaks.Both, "Speaker", "Choose who says the voice line."),
new Param("consecutive", false, "Consecutive Version", "Toggle if this cue should use the consecutive version of the cue. This mutes the first book flip so it doesn't overlap with a previous cue.")
}
},
new GameAction("okItsOn", "OK, It's On!")
@ -63,10 +73,10 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 4f,
parameters = new List<Param>()
{
new Param("solo", CheerReaders.WhoSpeaks.Both, "Who Speaks", "Who should say the voice line?"),
new Param("toggle", true, "Whistle", "Should the whistle sound play?"),
new Param("poster", CheerReaders.PosterToChoose.Random, "Poster", "Which image should the School Library Pep Squad display?"),
new Param("happy", true, "Make Happy Face?", "Will the School Library Pep Squad smile happily 2 beats after flipping their books?")
new Param("solo", CheerReaders.WhoSpeaks.Both, "Speaker", "Choose who says the voice line."),
new Param("toggle", true, "Whistle", "Toggle if the whistle sounds should play."),
new Param("poster", CheerReaders.PosterToChoose.Random, "Image", "Choose the image to display inside the books."),
new Param("happy", true, "Smile", "Toggle if the girls will smile two beats after the input.")
}
},
new GameAction("okItsOnStretch", "OK, It's On! (Stretchable)")
@ -76,10 +86,10 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("solo", CheerReaders.WhoSpeaks.Both, "Who Speaks", "Who should say the voice line?"),
new Param("toggle", true, "Whistle", "Should the whistle sound play?"),
new Param("poster", CheerReaders.PosterToChoose.Random, "Poster", "Which image should the School Library Pep Squad display?"),
new Param("happy", true, "Do Happy Face?", "Will the School Library Pep Squad smile happily 2 beats after showing off their books?")
new Param("solo", CheerReaders.WhoSpeaks.Both, "Speaker", "Choose who says the voice line."),
new Param("toggle", true, "Whistle", "Toggle if the whistle sounds should play."),
new Param("poster", CheerReaders.PosterToChoose.Random, "Image", "Choose the image to display inside the books."),
new Param("happy", true, "Smile", "Toggle if the girls should smile two beats after the input.")
}
},
new GameAction("yay", "Yay!")
@ -88,17 +98,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("solo", CheerReaders.WhoSpeaks.Both, "Who Speaks", "Who should say the voice line?"),
}
},
new GameAction("bop", "Bop")
{
function = delegate {var e = eventCaller.currentEntity; CheerReaders.instance.BopToggle(e.beat, e.length, e["toggle"], e["toggle2"]); },
resizable = true,
parameters = new List<Param>()
{
new Param("toggle", true, "Should bop?", "Should the girls bop?"),
new Param("toggle2", false, "Should auto bop?", "Should the girls bop automatically?")
new Param("solo", CheerReaders.WhoSpeaks.Both, "Speaker", "Choose who says the voice line."),
}
},
new GameAction("resetPose", "Reset Pose")

37
Assets/Scripts/Games/ClappyTrio/ClappyTrio.cs
View file

@ -16,48 +16,47 @@ namespace HeavenStudio.Games.Loaders
public static Minigame AddGame(EventCaller eventCaller) {
return new Minigame("clappyTrio", "The Clappy Trio", "deffff", false, false, new List<GameAction>()
{
new GameAction("clap", "Clap")
{
function = delegate { ClappyTrio.instance.Clap(eventCaller.currentEntity.beat, eventCaller.currentEntity.length, eventCaller.currentEntity.beat); },
resizable = true
},
new GameAction("bop", "Bop")
{
function = delegate { var e = eventCaller.currentEntity; ClappyTrio.instance.BopToggle(e.beat, e.length, e["bop"], e["autoBop"], e["emo"]); },
resizable = true,
parameters = new List<Param>()
{
new Param("bop", true, "Bop", "Should the lions bop?"),
new Param("autoBop", false, "Bop (Auto)", "Should the lions auto bop?"),
new Param("emo", false, "Disable Emotion", "Should the lions just show the neutral face while bopping?")
new Param("bop", true, "Bop", "Toggle if the lions should bop for the duration of this event."),
new Param("autoBop", false, "Bop (Auto)", "Toggle if the lions should automatically bop until another Bop event is reached."),
new Param("emo", false, "Disable Emotion", "Toggle if the (non-player) lions should react to the player's performance when bopping.")
}
},
new GameAction("prepare", "Prepare Stance")
new GameAction("clap", "Clap")
{
function = delegate { ClappyTrio.instance.Clap(eventCaller.currentEntity.beat, eventCaller.currentEntity.length, eventCaller.currentEntity.beat); },
resizable = true
},
new GameAction("prepare", "Prepare")
{
function = delegate { ClappyTrio.instance.Prepare(eventCaller.currentEntity["toggle"] ? 3 : 0); },
parameters = new List<Param>()
{
new Param("toggle", false, "Alt", "Whether or not the alternate version should be played")
new Param("toggle", false, "Alternate Pose", "Toggle if the lions should prepare using the alternate \"determined\" pose.")
}
},
new GameAction("sign", "Sign Enter")
new GameAction("sign", "Sign Control")
{
function = delegate { var e = eventCaller.currentEntity; ClappyTrio.instance.Sign(e.beat, e.length, e["ease"], e["down"], e["sfx"]); },
function = delegate { var e = eventCaller.currentEntity; ClappyTrio.instance.Sign(e.beat, e.length, e["ease"], e["down"]); },
parameters = new List<Param>()
{
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Which ease should the sign move with?"),
new Param("down", true, "Down", "Should the sign go down?"),
new Param("sfx", true, "Play SFX", "Should the sign play a sound effect"),
new Param("down", true, "Enter", "Toggle if the sign should enter or exit the scene."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.")
},
resizable = true
},
new GameAction("change lion count", "Change Lion Count")
new GameAction("change lion count", "Change Lion Number")
{
function = delegate { ClappyTrio.instance.ChangeLionCount((int)eventCaller.currentEntity["valA"]); },
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("valA", new EntityTypes.Integer(3, 8, 3), "Lion Count", "The amount of lions")
new Param("valA", new EntityTypes.Integer(3, 8, 3), "Lions", "Set how many lions there will be. The player is always the rightmost lion.")
}
},
// This is still here for backwards-compatibility but is hidden in the editor
@ -157,9 +156,9 @@ namespace HeavenStudio.Games
}
}
public void Sign(double beat, float length, int ease, bool down, bool playSfx)
public void Sign(double beat, float length, int ease, bool down)
{
if (playSfx) SoundByte.PlayOneShotGame("clappyTrio/sign");
SoundByte.PlayOneShotGame("clappyTrio/sign");
signStartBeat = beat;
signLength = length;
lastEase = (Util.EasingFunction.Ease)ease;

16
Assets/Scripts/Games/CoinToss/CoinToss.cs
View file

@ -18,11 +18,11 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 7,
parameters = new List<Param>()
{
new Param("type", CoinToss.CoinVariation.Default, "Variation", "Special Coin Variations"),
new Param("toggle", false, "Audience Reaction", "Enable Audience Reaction"),
new Param("type", CoinToss.CoinVariation.Default, "Variation", "Choose the version of the cue to play."),
new Param("toggle", false, "Audience Reaction", "Toggle if there should be cheering or booing after the cue."),
}
},
new GameAction("fade background color", "Background Color")
new GameAction("fade background color", "Background Appearance")
{
function = delegate { var e = eventCaller.currentEntity;
CoinToss.instance.BackgroundColor(e.beat, e.length, e["colorStart"], e["colorEnd"], e["colorStartF"], e["colorEndF"], e["ease"]); },
@ -30,11 +30,11 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 4f,
parameters = new List<Param>()
{
new Param("colorStart", CoinToss.defaultBgColor, "BG Start Color", "The starting color in the fade"),
new Param("colorEnd", CoinToss.defaultBgColor, "BG End Color", "The ending color in the fade"),
new Param("colorStartF", CoinToss.defaultBgColor, "FG Start Color", "The starting color in the fade"),
new Param("colorEndF", CoinToss.defaultBgColor, "FG End Color", "The ending color in the fade"),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease")
new Param("colorStart", CoinToss.defaultBgColor, "BG Start Color", "Set the color for the outer ring at the start of the event."),
new Param("colorEnd", CoinToss.defaultBgColor, "BG End Color", "Set the color for the outer ring at the end of the event."),
new Param("colorStartF", CoinToss.defaultBgColor, "FG Start Color", "Set the color for the inner oval at the start of the event."),
new Param("colorEndF", CoinToss.defaultBgColor, "FG End Color", "Set the color for the inner oval at the end of the event."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing for the action.")
}
},

17
Assets/Scripts/Games/CropStomp/CropStomp.cs
View file

@ -35,18 +35,18 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 2f,
parameters = new List<Param>()
{
new Param("mute", false, "Mute", "Should the mole laugh sound be muted?")
new Param("mute", false, "Mute", "Toggle if the mole laugh sound should be muted.")
},
preFunctionLength = 6
preFunctionLength = 3
},
new GameAction("end", "End")
{
parameters = new List<Param>()
{
new Param("mute", true, "Mute Humming?")
new Param("mute", true, "Toggle if Stomp Farmer should stopp humming.")
}
},
new GameAction("plantCollect", "Veggie Collection Values")
new GameAction("plantCollect", "Set Veggie Collection Thresholds")
{
function = delegate { var e = eventCaller.currentEntity;
CropStomp.instance.SetCollectThresholds(e["threshold"], e["limit"], e["force"], e["forceAmount"]);
@ -54,13 +54,13 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("threshold", new EntityTypes.Integer(1, 80, 8), "Threshold", "For each time the threshold is met a new plant will appear in the veggie bag."),
new Param("limit", new EntityTypes.Integer(1, 1000, 80), "Limit", "What is the limit for plants collected?"),
new Param("force", false, "Force Amount of Collected Plants", "", new List<Param.CollapseParam>()
new Param("threshold", new EntityTypes.Integer(1, 80, 8), "Threshold", "Set how many veggies it takes for a new plant to appear in the collection bag."),
new Param("limit", new EntityTypes.Integer(1, 1000, 80), "Limit", "Set the limit for the amount of plants to be collected and count towards the threshold."),
new Param("force", false, "Set Amount Of Collected Plants", "Toggle if this event should automatically set the collected plants to a certain number.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (bool)x, new string[] { "forceAmount" })
}),
new Param("forceAmount", new EntityTypes.Integer(0, 1000, 0), "Force Amount")
new Param("forceAmount", new EntityTypes.Integer(0, 1000, 0), "Set Amount", "Set the amount of plants to be collected automatically.")
}
}
},
@ -159,7 +159,6 @@ namespace HeavenStudio.Games
if (stepsPassed > 1000)
{
Debug.Log("Loop broke!");
return;
}
}

2
Assets/Scripts/Games/CropStomp/Veggie.cs
View file

@ -214,8 +214,6 @@ namespace HeavenStudio.Games.Scripts_CropStomp
}
gotStomped = true;
Debug.Log("Stomped!");
var cond = Conductor.instance;
ParticleSystem spawnedHit = Instantiate(game.hitParticle, game.hitParticle.transform.parent);

22
Assets/Scripts/Games/DJSchool/DJSchool.cs
View file

@ -18,8 +18,8 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("toggle2", true, "Bop", "Whether both will bop to the beat or not"),
new Param("toggle", false, "Bop (Auto)", "Whether both will auto bop to the beat or not")
new Param("toggle2", true, "Bop", "Toggle if the the DJs should bop for the duration of this event."),
new Param("toggle", false, "Bop (Auto)", "Toggle if the DJs should automatically bop until another Bop event is reached.")
}
},
new GameAction("and stop ooh", "And Stop!")
@ -29,7 +29,7 @@ namespace HeavenStudio.Games.Loaders
inactiveFunction = delegate { var e = eventCaller.currentEntity; DJSchool.WarnAndStop(e.beat, e["toggle"]); },
parameters = new List<Param>()
{
new Param("toggle", true, "Ooh", "Whether or not the \"ooh\" sound should be played")
new Param("toggle", true, "Ooh", "Toggle if DJ Yellow should say \"Ooh!\"")
}
},
new GameAction("break c'mon ooh", "Break, C'mon!")
@ -39,8 +39,8 @@ namespace HeavenStudio.Games.Loaders
inactiveFunction = delegate { var e = eventCaller.currentEntity; DJSchool.WarnBreakCmon(e.beat, e["type"], e["toggle"]); },
parameters = new List<Param>()
{
new Param("type", DJSchool.DJVoice.Standard, "Voice", "The voice line to play"),
new Param("toggle", true, "Ooh", "Whether or not the \"ooh\" sound should be played")
new Param("type", DJSchool.DJVoice.Standard, "Voice", "Choose the type of voice for DJ Yellow to use."),
new Param("toggle", true, "Ooh", "Toggle if DJ Yellow should say \"Ooh!\"")
}
},
new GameAction("scratch-o hey", "Scratch-o")
@ -49,9 +49,9 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 3f,
parameters = new List<Param>()
{
new Param("type", DJSchool.DJVoice.Standard, "Voice", "The voice line to play"),
new Param("toggle2", true, "Cheering", "Should cheering play when successfully hitting this cue?"),
new Param("toggle", false, "Fast Hey", "Activate Remix 4 (DS) beat")
new Param("type", DJSchool.DJVoice.Standard, "Voice", "Choose the type of voice for DJ Yellow to use."),
new Param("toggle2", true, "Cheering", "Toggle if cheering should play if you successfully hit this cue."),
new Param("toggle", false, "Fast Hey", "Toggle if this cue should use the faster timing from Remix 4 (DS).")
}
},
new GameAction("dj voice lines", "DJ Yellow Banter")
@ -61,16 +61,16 @@ namespace HeavenStudio.Games.Loaders
inactiveFunction = delegate { DJSchool.VoiceLines(eventCaller.currentEntity.beat, eventCaller.currentEntity["type"]); },
parameters = new List<Param>()
{
new Param("type", DJSchool.DJVoiceLines.CheckItOut, "Voice Lines", "The voice line to play"),
new Param("type", DJSchool.DJVoiceLines.CheckItOut, "Voice Line", "Choose what DJ Yellow should say."),
}
},
new GameAction("sound FX", "Scratchy Music")
new GameAction("sound FX", "Set Radio FX")
{
function = delegate { DJSchool.SoundFX(eventCaller.currentEntity["toggle"]); },
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("toggle", true, "Radio FX", "Toggle on and off for Radio Effects")
new Param("toggle", true, "Radio FX", "Toggle if holding down the record will trigger scratchy radio effects like in the original game.")
}
},
new GameAction("forceHold", "Force Hold")

20
Assets/Scripts/Games/DogNinja/DogNinja.cs
View file

@ -21,8 +21,8 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("toggle", true, "Enable Bopping", "Whether to bop to the beat or not"),
new Param("auto", false, "Enable Bopping (Auto)", "Whether to bop to the beat or not automatically"),
new Param("toggle", true, "Bop", "Toggle if Dog Ninja should bop for the duration of this event."),
new Param("auto", false, "Bop (Auto)", "Toggle if Dog Ninja should automatically bop until another Bop event is reached."),
}
},
new GameAction("Prepare", "Prepare")
@ -37,21 +37,21 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 2,
parameters = new List<Param>()
{
new Param("direction", DogNinja.ObjectDirection.Left, "Which Side", "Whether the object should come from the left, right, or both sides"),
new Param("typeL", DogNinja.ObjectType.Random, "Left \nObject", "The object to be thrown from the left"),
new Param("typeR", DogNinja.ObjectType.Random, "Right Object", "The object to be thrown from the right"),
new Param("shouldPrepare", true, "Prepare?", "Should the dog prepare?"),
new Param("muteThrow", false, "Mute", "Mute the throw? (ONLY WHEN INACTIVE)"),
new Param("direction", DogNinja.ObjectDirection.Left, "Which Side", "Choose the side(s) the object(s) should be thrown from."),
new Param("typeL", DogNinja.ObjectType.Random, "Left Object", "Choose the object to be thrown from the left."),
new Param("typeR", DogNinja.ObjectType.Random, "Right Object", "Choose the object to be thrown from the right."),
new Param("shouldPrepare", true, "Prepare", "Toggle if Dog Ninja should automatically prepare for this cue."),
new Param("muteThrow", false, "Mute", "Toggle if the cue should be muted. This only applies when the cue is started from another game."),
},
},
new GameAction("CutEverything", "Cut Everything!")
new GameAction("CutEverything", "Mister Eagle's Sign")
{
function = delegate { var e = eventCaller.currentEntity; DogNinja.instance.CutEverything(e.beat, e["toggle"], e["text"]); },
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("toggle", true, "Play Sound", "Whether to play the 'FlyIn' SFX or not"),
new Param("text", "Cut everything!", "Custom Text", "What text should the sign display?")
new Param("toggle", true, "Play Sound", "Toggle if the sound effect should play for flying in and out."),
new Param("text", "Cut everything!", "Sign Text", "Set the text to be displayed on the sign.")
}
},
new GameAction("HereWeGo", "Here We Go!")

20
Assets/Scripts/Games/DoubleDate/DoubleDate.cs
View file

@ -17,8 +17,8 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("bop", true, "Bop", "Should the two couples bop?"),
new Param("autoBop", false, "Bop (Auto)", "Should the two couples auto bop?")
new Param("bop", true, "Bop", "Toggle if the two couples should bop for the duration of this event."),
new Param("autoBop", false, "Bop (Auto)", "Toggle if the two couples should automatically bop until another Bop event is reached.")
}
},
new GameAction("soccer", "Soccer Ball")
@ -28,7 +28,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 2f,
parameters = new()
{
new("b", false, "Weasels Jump")
new("b", false, "Weasels Jump", "Toggle if the weasels should jump upon successfully hitting the cue.")
}
},
new GameAction("basket", "Basket Ball")
@ -38,7 +38,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 2f,
parameters = new()
{
new("b", false, "Weasels Jump")
new("b", false, "Weasels Jump", "Toggle if the weasels should jump upon successfully hitting the cue.")
}
},
new GameAction("football", "Football")
@ -48,29 +48,29 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 2.5f,
parameters = new()
{
new("b", true, "Weasels Jump")
new("b", true, "Weasels Jump", "Toggle if the weasels should jump upon successfully hitting the cue.")
}
},
new GameAction("blush", "Blush")
{
function = delegate { DoubleDate.instance.GirlBlush(); }
},
new GameAction("toggleGirls", "Girls Presence")
new GameAction("toggleGirls", "Set Girls' Presence")
{
function = delegate { DoubleDate.instance.ToggleGirls(eventCaller.currentEntity["b"]); },
defaultLength = 0.5f,
parameters = new()
{
new("b", false, "Present?")
new("b", false, "Present", "Toggle if the girl and the female weasel should appear.")
}
},
new GameAction("stare", "Boy Stare")
new GameAction("stare", "Boy Looks")
{
function = delegate { DoubleDate.instance.ToggleStare(eventCaller.currentEntity["b"]); },
defaultLength = 0.5f,
parameters = new()
{
new("b", true, "Should stare?")
new("b", true, "Look", "Toggle if the boy should look at the girl.")
}
},
new GameAction("time", "Time of Day")
@ -79,7 +79,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 0.5f,
parameters = new()
{
new("d", DoubleDate.DayTime.Noon, "Time")
new("d", DoubleDate.DayTime.Noon, "Time", "Set the time of day.")
}
}
},

34
Assets/Scripts/Games/DrummingPractice/DrummingPractice.cs
View file

@ -20,8 +20,8 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("bop", true, "Bop", "Should the drummers bop?"),
new Param("autoBop", false, "Bop (Auto)", "Should the drummers auto bop?")
new Param("bop", true, "Bop", "Toggle if the drummers should bop for the duration of this event."),
new Param("autoBop", false, "Bop (Auto)", "Toggle if the drummers should automatically bop until another Bop event is reached.")
}
},
new GameAction("drum", "Hit Drum")
@ -30,7 +30,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 2f,
parameters = new List<Param>()
{
new Param("toggle", true, "Applause", "Whether or not an applause should be played on a successful hit")
new Param("toggle", true, "Applause", "Toggle if applause should be played on a successful hit.")
}
},
new GameAction("set mii", "Set Miis")
@ -39,27 +39,27 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("toggle", false, "Set All to Player", "Sets all Miis to the Player's Mii", new List<Param.CollapseParam>()
new Param("toggle", false, "Set All To Player", "Toggle if all Miis should be set to the player's (middle) Mii.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => !(bool)x, new string[] { "type", "type2", "type3" })
}),
new Param("type", DrummingPractice.MiiType.Random, "Player Mii", "The Mii that the player will control"),
new Param("type2", DrummingPractice.MiiType.Random, "Left Mii", "The Mii on the left"),
new Param("type3", DrummingPractice.MiiType.Random, "Right Mii", "The Mii on the right"),
new Param("type", DrummingPractice.MiiType.Random, "Player Mii", "Set the Mii that the player will control."),
new Param("type2", DrummingPractice.MiiType.Random, "Left Mii", "Set the Mii on the left."),
new Param("type3", DrummingPractice.MiiType.Random, "Right Mii", "Set the Mii on the right."),
}
},
new GameAction("move npc drummers", "NPC Drummers Enter or Exit")
new GameAction("move npc drummers", "NPC Drummers")
{
function = delegate {var e = eventCaller.currentEntity; DrummingPractice.instance.NPCDrummersEnterOrExit(e.beat, e.length, e["exit"], e["ease"]); },
defaultLength = 4f,
resizable = true,
parameters = new List<Param>()
{
new Param("exit", false, "Exit?", "Should the NPC drummers exit or enter?"),
new Param("ease", EasingFunction.Ease.Linear, "Ease", "Which ease should the movement have?")
new Param("exit", false, "Exit", "Toggle if the NPC drummers should enter or exit the scene."),
new Param("ease", EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.")
}
},
new GameAction("set background color", "Background Color")
new GameAction("set background color", "Background Appearance")
{
function = delegate {var e = eventCaller.currentEntity;
DrummingPractice.instance.BackgroundColor(e.beat, e.length, e["colorAStart"], e["colorA"], e["colorBStart"], e["colorB"], e["colorC"], e["ease"]); },
@ -67,12 +67,12 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("colorAStart", new Color(43/255f, 207/255f, 51/255f), "Color A Start", "The top-most color of the background gradient"),
new Param("colorA", new Color(43/255f, 207/255f, 51/255f), "Color A End", "The top-most color of the background gradient"),
new Param("colorBStart", new Color(1, 1, 1), "Color B Start", "The bottom-most color of the background gradient"),
new Param("colorB", new Color(1, 1, 1), "Color B End", "The bottom-most color of the background gradient"),
new Param("colorC", new Color(1, 247/255f, 0), "Streak Color", "The color of streaks that appear on a successful hit"),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease")
new Param("colorAStart", new Color(43/255f, 207/255f, 51/255f), "Color A Start", "Set the top-most color of the background gradient at the start of the event."),
new Param("colorA", new Color(43/255f, 207/255f, 51/255f), "Color A End", "Set the top-most color of the background gradient at the end of the event."),
new Param("colorBStart", new Color(1, 1, 1), "Color B Start", "Set the bottom-most color of the background gradient at the start of the event."),
new Param("colorB", new Color(1, 1, 1), "Color B End", "Set the bottom-most color of the background gradient at the end of the event."),
new Param("colorC", new Color(1, 247/255f, 0), "Streak Color", "Set the color of the streaks that appear upon a successful hit."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.")
}
}
},

32
Assets/Scripts/Games/FanClub/FanClub.cs
View file

@ -20,8 +20,8 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("type", FanClub.IdolBopType.Both, "Bop target", "Who to make bop"),
new Param("type2", FanClub.IdolBopType.None, "Bop target (Auto)", "Who to make auto bop"),
new Param("type", FanClub.IdolBopType.Both, "Bop", "Set the character(s) to bop for the duration of this event."),
new Param("type2", FanClub.IdolBopType.None, "Bop", "Set the character(s) to automatically bop until another Bop event is reached."),
}
},
new GameAction("yeah, yeah, yeah", "Yeah, Yeah, Yeah!")
@ -30,8 +30,8 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 8,
parameters = new List<Param>()
{
new Param("toggle", false, "Disable call", "Disable the idol's call"),
new Param("toggle2", false, "Disable response SFX", "Disable the monkeys's response")
new Param("toggle", false, "Mute Arisa", "Toggle if Arisa's cue should be muted."),
new Param("toggle2", false, "Mute Monkey SFX", "Toggle if the monkey's (including the player's) sound effects should be muted.")
},
inactiveFunction = delegate { var e = eventCaller.currentEntity; FanClub.WarnHai(e.beat, e["toggle"]);},
preFunction = delegate { var e = eventCaller.currentEntity; FanClub.HaiSound(e.beat, e["toggle"], e["toggle2"]); }
@ -43,9 +43,9 @@ namespace HeavenStudio.Games.Loaders
parameters = new List<Param>()
{
new Param("type", FanClub.KamoneResponseType.Through, "Response type", "Type of response to use"),
new Param("toggle", false, "Disable call", "Disable the idol's call"),
new Param("toggle2", false, "Disable response SFX", "Disable the monkeys's response"),
new Param("alt", false, "Alternate cue", "Use an alternate cue")
new Param("toggle", false, "Mute Arisa", "Toggle if Arisa's cue should be muted."),
new Param("toggle2", false, "Mute Monkey SFX", "Toggle if the monkey's (including the player's) sound effects should be muted."),
new Param("alt", false, "Alternate cue", "Toggle if Arisa should use the \"Wonderful\" (iina) cue.")
},
inactiveFunction = delegate { var e = eventCaller.currentEntity; FanClub.WarnKamone(e.beat, e["toggle"], 0, e["type"], e["alt"]);},
preFunction = delegate { var e = eventCaller.currentEntity; FanClub.KamoneSound(e.beat, e["toggle"], e["toggle2"], 0, e["type"], e["alt"]); }
@ -56,7 +56,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 4,
parameters = new List<Param>()
{
new Param("toggle", false, "Disable call", "Disable the call")
new Param("toggle", false, "Disable Call", "Toggle if the monkey's \"Ooh!\" cue should play.")
},
inactiveFunction = delegate { var e = eventCaller.currentEntity; FanClub.WarnBigReady(e.beat, e["toggle"]); },
preFunction = delegate { var e = eventCaller.currentEntity; FanClub.BigReadySound(e.beat, e["toggle"]); }
@ -67,28 +67,28 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("type", FanClub.IdolAnimations.Bop, "Animation", "Animation to play"),
new Param("who", FanClub.IdolType.All, "Target Idol", "Target to play the animation on")
new Param("type", FanClub.IdolAnimations.Bop, "Animation", "Set the animation to play."),
new Param("who", FanClub.IdolType.All, "Target Idol", "Set the character to perform the above animation.")
}
},
new GameAction("play stage animation", "Stage Coreography")
new GameAction("play stage animation", "Stage Effects")
{
function = delegate { var e = eventCaller.currentEntity; FanClub.instance.PlayAnimStage(e.beat, e["type"]); },
resizable = true,
parameters = new List<Param>()
{
new Param("type", FanClub.StageAnimations.Flash, "Animation", "Animation to play")
new Param("type", FanClub.StageAnimations.Flash, "Effect", "Set the effect to play.")
}
},
new GameAction("friend walk", "Backup Dancers Entrance")
new GameAction("friend walk", "Backup Dancers")
{
function = delegate { var e = eventCaller.currentEntity; FanClub.instance.DancerTravel(e.beat, e.length, e["exit"], e["instant"]); },
defaultLength = 16f,
resizable = true,
parameters = new List<Param>()
{
new Param("exit", false, "Exit", "Backup dancers exit instead"),
new Param("instant", false, "Instant Travel", "Backup dancers instantly finish their travel"),
new Param("exit", false, "Exit", "Toggle if the backup dancers should enter or exit the scene."),
new Param("instant", false, "Instant", "Toggle if the backup dancers should instantly finish their enter/exit."),
}
},
new GameAction("set performance type", "Coreography Type")
@ -98,7 +98,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("type", FanClub.IdolPerformanceType.Normal, "Performance Type", "Set of animations for the idol to use")
new Param("type", FanClub.IdolPerformanceType.Normal, "Performance Type", "Set the type animations for Arisa to use.")
},
inactiveFunction = delegate { var e = eventCaller.currentEntity; FanClub.SetPerformanceType(e["type"]); }
},

28
Assets/Scripts/Games/Fireworks/Fireworks.cs
View file

@ -19,11 +19,11 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 4f,
parameters = new List<Param>()
{
new Param("whereToSpawn", Fireworks.WhereToSpawn.Middle, "Where to spawn?", "Where should the firework spawn?"),
new Param("explosionType", Fireworks.ExplosionType.MixedCircular, "Explosion Pattern", "What pattern should the firework explode with?"),
new Param("applause", false, "Applause", "Should an applause play after successfully hitting this cue?"),
new Param("offSet", new EntityTypes.Float(0, 4, 0), "Vertical Offset", "What vertical Offset should the rocket have?"),
new Param("toggle", false, "Practice Count-In", "Should the count-in from the fireworks practice play?")
new Param("whereToSpawn", Fireworks.WhereToSpawn.Middle, "Side", "Choose the side this firework should spawn on."),
new Param("explosionType", Fireworks.ExplosionType.MixedCircular, "Pattern", "Choose the pattern that this firework should explode into."),
new Param("applause", false, "Applause", "Toggle if applause should play if you successfully hit this cue."),
new Param("offSet", new EntityTypes.Float(0, 4, 0), "Vertical Offset", "Choose the verical offset for this firework."),
new Param("toggle", false, "Count-In", "Toggle if a count-in should automatically play for this cue, as shown in the practice of the original game.")
}
},
new GameAction("sparkler", "Sparkler")
@ -32,11 +32,11 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 2f,
parameters = new List<Param>()
{
new Param("whereToSpawn", Fireworks.WhereToSpawn.Middle, "Where to spawn?", "Where should the firework spawn?"),
new Param("explosionType", Fireworks.ExplosionType.MixedCircular, "Explosion Pattern", "What pattern should the firework explode with?"),
new Param("applause", false, "Applause", "Should an applause play after successfully hitting this cue?"),
new Param("offSet", new EntityTypes.Float(0, 4, 0), "Vertical Offset", "What vertical Offset should the rocket have?"),
new Param("toggle", false, "Practice Count-In", "Should the count-in from the fireworks practice play?")
new Param("whereToSpawn", Fireworks.WhereToSpawn.Middle, "Side", "Choose the side this firework should spawn on."),
new Param("explosionType", Fireworks.ExplosionType.MixedCircular, "Pattern", "Choose the pattern that this sparkler should explode into."),
new Param("applause", false, "Applause", "Toggle if applause should play if you successfully hit this cue."),
new Param("offSet", new EntityTypes.Float(0, 4, 0), "Vertical Offset", "Choose the vertical offset for this sparkler."),
new Param("toggle", false, "Count-In", "Toggle if a count-in should automatically play for this cue, as shown in the practice of the original game.")
}
},
new GameAction("bomb", "Bomb")
@ -45,8 +45,8 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 3f,
parameters = new List<Param>()
{
new Param("applause", false, "Applause", "Should an applause play after successfully hitting this cue?"),
new Param("toggle", false, "Practice Count-In", "Should the count-in from the fireworks practice play?")
new Param("applause", false, "Applause", "Toggle if applause should play if you successfully hit this cue."),
new Param("toggle", false, "Count-In", "Toggle if a count-in should automatically play for this cue, as shown in the practice of the original game.")
}
},
new GameAction("countIn", "Count-In")
@ -55,7 +55,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 1f,
parameters = new List<Param>()
{
new Param("count", Fireworks.CountInType.CountOne, "Count", "Which count should be said?")
new Param("count", Fireworks.CountInType.CountOne, "Type", "Set the number to be said.")
}
},
new GameAction("altBG", "Background Appearance")
@ -64,7 +64,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("toggle", true, "Remix 5", "Should the background from Remix 5 tengoku appear?")
new Param("toggle", true, "Remix 5", "Togle if the background from Remix 5 (GBA) should appear.")
}
}
},

26
Assets/Scripts/Games/FirstContact/FirstContact.cs
View file

@ -23,8 +23,8 @@ namespace HeavenStudio.Games.Loaders
preFunction = delegate { var e = eventCaller.currentEntity; FirstContact.PreInterval(e.beat, e.length, e["dialogue"], e["auto"]); },
parameters = new List<Param>()
{
new Param("dialogue", "REPLACE THIS", "Mistranslation Dialogue", "The line to use when messing up the translation"),
new Param("auto", true, "Auto Pass Turn")
new Param("dialogue", "REPLACE THIS", "Mistranslation Dialogue", "Set the line to use when messing up the translation."),
new Param("auto", true, "Auto Pass Turn", "Toggle if the turn should be passed automatically at the end of the start interval.")
},
defaultLength = 3f,
resizable = true,
@ -35,10 +35,10 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("spaceNum", new EntityTypes.Integer(0, 12, 0), "Amount of spaces", "Spaces to add before the untranslated icon"),
new Param("dotdotdot", false, "Has ellipses?", "Will the man symbol be proceeded by a <...>?"),
new Param("newline", false, "New line?", "Should this text start a new line?"),
new Param("dialogue", "", "Dialogue", "What should this sound translate to?")
new Param("spaceNum", new EntityTypes.Integer(0, 12, 0), "Amount Of Spaces", "Choose the amount of spaces to add before the icon."),
new Param("dotdotdot", false, "Ellipses", "Toggle if the symbol should have \"...\" before it."),
new Param("newline", false, "New line", "Toggle if this text starts a new line."),
new Param("dialogue", "", "Translation", "Set the text that this syllable will translate to. Spaces will not be automatically added.")
},
priority = 1
},
@ -57,26 +57,26 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>
{
new Param("toggle", false, "Stay", "If it's the end of the remix/song")
new Param("toggle", false, "Stay", "Toggle if the camera should stay on mission control even after the event has ended. This is usually used for the end of a level.")
}
},
new GameAction("look at", "Look At")
new GameAction("look at", "Look")
{
function = delegate { FirstContact.instance.LookAtDirection(eventCaller.currentEntity["type"], eventCaller.currentEntity["type2"]); },
defaultLength = .5f,
parameters = new List<Param>()
{
new Param("type", FirstContact.alienLookAt.lookAtAlien, "Bob look at what", "[Bob] will look at what"),
new Param("type2", FirstContact.translatorLookAt.lookAtBob, "Alien look at what", "[Alien] will look at what"),
new Param("type", FirstContact.alienLookAt.lookAtAlien, "Farmer Bob", "Set where Farmer Bob will look."),
new Param("type2", FirstContact.translatorLookAt.lookAtBob, "Alien", "Set where the alien will look."),
}
},
new GameAction("live bar beat", "Live Bar Beat")
new GameAction("live bar beat", "\"Live\" Bar")
{
function = delegate { FirstContact.instance.LiveBarBeat(eventCaller.currentEntity["toggle"]); },
defaultLength = .5f,
parameters = new List<Param>()
{
new Param("toggle", true, "On Beat", "If the live bar animation will be on beat or not")
new Param("toggle", true, "On Beat", "Toggle if the \"Live\" bar in the top-left will animate on onbeats or offbeats.")
}
}
},
@ -345,8 +345,6 @@ namespace HeavenStudio.Games
public void LookAtDirection(int alienLookAt, int translatorLookAt)
{
Debug.Log(alienLookAt);
Debug.Log(translatorLookAt);
switch (alienLookAt)
{
case 0:

42
Assets/Scripts/Games/FlipperFlop/FlipperFlop.cs
View file

@ -13,22 +13,32 @@ namespace HeavenStudio.Games.Loaders
{
return new Minigame("flipperFlop", "Flipper-Flop", "ffc3fc", false, false, new List<GameAction>()
{
new GameAction("bop", "Bop")
{
function = delegate {var e = eventCaller.currentEntity; FlipperFlop.instance.Bop(e.beat, e.length, e["whoBops"], e["whoBopsAuto"]); },
resizable = true,
parameters = new List<Param>()
{
new Param("whoBops", FlipperFlop.WhoBops.Both, "Bop", "Set the character(s) to bop for the duration of this event."),
new Param("whoBopsAuto", FlipperFlop.WhoBops.None, "Bop (Auto)", "Set the character(s) to automatically bop until another Bop event is reached."),
}
},
new GameAction("attentionCompany", "Attention Company!")
{
preFunction = delegate {var e = eventCaller.currentEntity; FlipperFlop.AttentionCompany(e.beat, e["toggle"]); },
defaultLength = 4f,
parameters = new List<Param>()
{
new Param("toggle", false, "Mute VoiceLine", "Mute Captain Tuck's voiceline?")
new Param("toggle", false, "Mute", "Toggle if Captain Tuck's voice line should be muted.")
}
},
new GameAction("attentionCompanyAlt", "Attention Company! (Remix 5)")
new GameAction("attentionCompanyAlt", "Attention Company! (Remix 5 Wii)")
{
preFunction = delegate {var e = eventCaller.currentEntity; FlipperFlop.AttentionCompany(e.beat, e["toggle"], true); },
defaultLength = 3f,
parameters = new List<Param>()
{
new Param("toggle", false, "Mute VoiceLine", "Mute Captain Tuck's voiceline?")
new Param("toggle", false, "Mute", "Toggle if Captain Tuck's voice line should be muted.")
}
},
new GameAction("flipping", "Flipping")
@ -47,8 +57,8 @@ namespace HeavenStudio.Games.Loaders
preFunction = delegate {var e = eventCaller.currentEntity; FlipperFlop.FlipperRollVoiceLine(e.beat, e["amount"], e["toggle"]); },
parameters = new List<Param>()
{
new Param("amount", new EntityTypes.Integer(1, 10, 1), "Amount", "1, 2, 3... etc. - flipper rolls"),
new Param("toggle", false, "Now", "Whether Captain Tuck should say -Now!- instead of numbers.")
new Param("amount", new EntityTypes.Integer(1, 10, 1), "Amount", "Set the number that Captain Tuck should announce."),
new Param("toggle", false, "Now", "Toggle if Captain Tuck should say \"Now\" instead of a number.")
},
defaultLength = 2f
},
@ -57,31 +67,21 @@ namespace HeavenStudio.Games.Loaders
preFunction = delegate {var e = eventCaller.currentEntity; FlipperFlop.Flipping(e.beat, e.length, true, e["uh"], e["thatsIt"], e["appreciation"], e["heart"], e["barber"]); },
parameters = new List<Param>()
{
new Param("uh", new EntityTypes.Integer(0, 3, 0), "Uh Count", "How many Uhs should Captain Tuck say after the flippers roll?"),
new Param("appreciation", FlipperFlop.AppreciationType.None, "Appreciation", "Which appreciation line should Captain Tuck say?", new List<Param.CollapseParam>()
new Param("uh", new EntityTypes.Integer(0, 3, 0), "Grunt Count", "Choose how many grunts Captain Tuck should say after the flipper-rolls."),
new Param("appreciation", FlipperFlop.AppreciationType.None, "Appreciation", "Choose the appreciation voice line that Captain Tuck should say if the flipper-roll is carried out successfully.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (int)x != (int)FlipperFlop.AppreciationType.None, new string[] { "heart" })
}),
new Param("heart", false, "Hearts", "Should Captain Tuck blush and make hearts appear when he expresses his appreciation?"),
new Param("thatsIt", false, "That's it!", "Whether or not Captain Tuck should say -That's it!- on the final flipper roll.", new List<Param.CollapseParam>()
new Param("heart", false, "Hearts", "Toggle if Captain Tuck should blush and make hearts appear when he expresses his appreciation."),
new Param("thatsIt", false, "That's it!", "Toggle if Captain Tuck should say \"That's it!\" after the flipper-rolls. This is usually used for the end of a level or segment.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (bool)x, new string[] { "barber" })
}),
new Param("barber", false, "Barbershop that's it variant", "Should captain tuck use the Barbershop remix variant of that's it?")
new Param("barber", false, "Barbershop", "Toggle if Captain Tuck should use the variant of \"That's it!\" seen in Barbershop Remix (3DS).")
},
defaultLength = 4f,
resizable = true
},
new GameAction("bop", "Bop")
{
function = delegate {var e = eventCaller.currentEntity; FlipperFlop.instance.Bop(e.beat, e.length, e["whoBops"], e["whoBopsAuto"]); },
resizable = true,
parameters = new List<Param>()
{
new Param("whoBops", FlipperFlop.WhoBops.Both, "Who Bops?", "Who will bop?"),
new Param("whoBopsAuto", FlipperFlop.WhoBops.None, "Who Bops? (Auto)", "Who will auto bop?"),
}
},
new GameAction("walk", "Captain Tuck Walk")
{
function = delegate { var e = eventCaller.currentEntity; FlipperFlop.instance.CaptainWalk(e.beat, e.length, e["ease"]); },
@ -89,7 +89,7 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("ease", EasingFunction.Ease.Linear, "Ease", "Which ease should the animation be played at?")
new Param("ease", EasingFunction.Ease.Linear, "Ease", "Set the easing for the action.")
}
},
new GameAction("toggleCaptain", "Disable/Enable Captain Tuck")

20
Assets/Scripts/Games/ForkLifter/ForkLifter.cs
View file

@ -22,7 +22,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 3,
parameters = new List<Param>()
{
new Param("type", ForkLifter.FlickType.Pea, "Object", "The object to be flicked")
new Param("type", ForkLifter.FlickType.Pea, "Object", "Choose the object to be flicked.")
},
inactiveFunction = delegate {
var e = eventCaller.currentEntity;
@ -36,7 +36,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("mute", false, "Mute Prepare")
new Param("mute", false, "Mute", "Toggle if the prepare sound effect should play.")
}
},
new GameAction("gulp", "Swallow")
@ -47,25 +47,25 @@ namespace HeavenStudio.Games.Loaders
{
function = delegate { SoundByte.PlayOneShot("games/forkLifter/sigh"); }
},
new GameAction("color", "Background Color")
new GameAction("color", "Background Appearance")
{
function = delegate { var e = eventCaller.currentEntity; ForkLifter.instance.BackgroundColor(e.beat, e.length, e["start"], e["end"], e["ease"]); },
parameters = new List<Param>()
{
new Param("start", Color.white, "Start Color", "The color to start fading from."),
new Param("end", Color.white, "End Color", "The color to end the fade."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease")
new Param("start", Color.white, "Start Color", "Set the color at the start of the event."),
new Param("end", Color.white, "End Color", "Set the color at the end of the event."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.")
},
resizable = true
},
new GameAction("colorGrad", "Gradient Color")
new GameAction("colorGrad", "Gradient Appearance")
{
function = delegate { var e = eventCaller.currentEntity; ForkLifter.instance.BackgroundColorGrad(e.beat, e.length, e["start"], e["end"], e["ease"]); },
parameters = new List<Param>()
{
new Param("start", Color.white, "Start Color", "The color to start fading from."),
new Param("end", Color.white, "End Color", "The color to end the fade."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease")
new Param("start", Color.white, "Start Color", "Set the color at the start of the event."),
new Param("end", Color.white, "End Color", "Set the color at the end of the event."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.")
},
resizable = true
},

44
Assets/Scripts/Games/GleeClub/GleeClub.cs
View file

@ -26,17 +26,17 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("semiTones", new EntityTypes.Integer(-24, 24, -5), "Semitones", "The number of semitones up or down this note should be pitched"),
new Param("semiTones1", new EntityTypes.Integer(-24, 24, -1), "Semitones (Next)", "The number of semitones up or down this note should be pitched"),
new Param("semiTonesPlayer", new EntityTypes.Integer(-24, 24, 2), "Semitones (Player)", "The number of semitones up or down this note should be pitched"),
new Param("close", GleeClub.MouthOpenClose.Both, "Close/Open Mouth", "Should the chorus kids close/open their mouth?"),
new Param("repeat", false, "Repeating", "Should the left and middle chorus kid repeat this singing cue?", new List<Param.CollapseParam>()
new Param("semiTones", new EntityTypes.Integer(-24, 24, -5), "Semitones", "Set the number of semitones up or down this note should be pitched."),
new Param("semiTones1", new EntityTypes.Integer(-24, 24, -1), "Semitones (Next)", "Set the number of semitones up or down this note should be pitched."),
new Param("semiTonesPlayer", new EntityTypes.Integer(-24, 24, 2), "Semitones (Player)", "Set the number of semitones up or down this note should be pitched."),
new Param("close", GleeClub.MouthOpenClose.Both, "Close/Open Mouth", "Choose if the chorus kids should close or open their mouth."),
new Param("repeat", false, "Repeating", "Toggle if the left and middle chorus kid should repeat this singing cue.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (bool)x, new string[] { "semiTonesLeft2", "semiTonesLeft3", "semiTonesMiddle2" })
}),
new Param("semiTonesLeft2", new EntityTypes.Integer(-24, 24, 0), "Semitones (Repeat Left First)", "The number of semitones up or down this note should be pitched"),
new Param("semiTonesLeft3", new EntityTypes.Integer(-24, 24, 0), "Semitones (Repeat Left Last)", "The number of semitones up or down this note should be pitched"),
new Param("semiTonesMiddle2", new EntityTypes.Integer(-24, 24, 0), "Semitones (Repeat Middle)", "The number of semitones up or down this note should be pitched"),
new Param("semiTonesLeft2", new EntityTypes.Integer(-24, 24, 0), "Semitones (Repeat Left First)", "Set the number of semitones up or down this note should be pitched."),
new Param("semiTonesLeft3", new EntityTypes.Integer(-24, 24, 0), "Semitones (Repeat Left Last)", "Set the number of semitones up or down this note should be pitched."),
new Param("semiTonesMiddle2", new EntityTypes.Integer(-24, 24, 0), "Semitones (Repeat Middle)", "Set the number of semitones up or down this note should be pitched."),
}
},
new GameAction("baton", "Baton")
@ -50,10 +50,10 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 4f,
parameters = new List<Param>()
{
new Param("semiTones", new EntityTypes.Integer(-24, 24, -1), "Semitones", "The number of semitones up or down this note should be pitched"),
new Param("semiTones1", new EntityTypes.Integer(-24, 24, 4), "Semitones (Next)", "The number of semitones up or down this note should be pitched"),
new Param("semiTonesPlayer", new EntityTypes.Integer(-24, 24, 10), "Semitones (Player)", "The number of semitones up or down this note should be pitched"),
new Param("pitch", new EntityTypes.Float(0f, 5f, 1f), "Conductor Voice Pitch", "Which pitch should the conductor's voice be at? (1 is normal pitch)")
new Param("semiTones", new EntityTypes.Integer(-24, 24, -1), "Semitones", "Set the number of semitones up or down this note should be pitched."),
new Param("semiTones1", new EntityTypes.Integer(-24, 24, 4), "Semitones (Next)", "Set the number of semitones up or down this note should be pitched."),
new Param("semiTonesPlayer", new EntityTypes.Integer(-24, 24, 10), "Semitones (Player)", "Set the number of semitones up or down this note should be pitched."),
new Param("pitch", new EntityTypes.Float(0f, 5f, 1f), "Conductor Voice Pitch", "Choose the pitch of the conductor's voice. 1 is normal pitch.")
}
},
new GameAction("forceSing", "Force Sing")
@ -62,20 +62,20 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("semiTones", new EntityTypes.Integer(-24, 24, 0), "Semitones", "The number of semitones up or down this note should be pitched"),
new Param("semiTones1", new EntityTypes.Integer(-24, 24, 0), "Semitones (Next)", "The number of semitones up or down this note should be pitched"),
new Param("semiTonesPlayer", new EntityTypes.Integer(-24, 24, 0), "Semitones (Player)", "The number of semitones up or down this note should be pitched"),
new Param("semiTones", new EntityTypes.Integer(-24, 24, 0), "Semitones", "Set the number of semitones up or down this note should be pitched."),
new Param("semiTones1", new EntityTypes.Integer(-24, 24, 0), "Semitones (Next)", "Set the number of semitones up or down this note should be pitched."),
new Param("semiTonesPlayer", new EntityTypes.Integer(-24, 24, 0), "Semitones (Player)", "Set the number of semitones up or down this note should be pitched."),
}
},
new GameAction("presence", "Toggle Chorus Kids Presence")
new GameAction("presence", "Toggle Chorus Kids")
{
function = delegate { var e = eventCaller.currentEntity; GleeClub.instance.ToggleKidsPresence(!e["left"], !e["middle"], !e["player"]); },
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("left", false, "Left Kid Present", "Should this chorus kid be present?"),
new Param("middle", false, "Middle Kid Present", "Should this chorus kid be present?"),
new Param("player", false, "Player Kid Present", "Should this chorus kid be present?"),
new Param("left", false, "Left Kid Present", "Toggle if this chorus kid should be present."),
new Param("middle", false, "Middle Kid Present", "Toggle if this chorus kid should be present."),
new Param("player", false, "Player Kid Present", "Toggle if this chorus kid should be present."),
}
},
new GameAction("fadeOutTime", "Set Sing Game-Switch Fade Out Time")
@ -84,9 +84,9 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("fade", new EntityTypes.Float(0, 20f, 0f), "Left Chorus Kid", "For how much time in seconds should this chorus kid's singing fade out?"),
new Param("fade1", new EntityTypes.Float(0, 20f, 0f), "Middle Chorus Kid", "For how much time in seconds should this chorus kid's singing fade out?"),
new Param("fadeP", new EntityTypes.Float(0, 20f, 0f), "Player Chorus Kid", "For how much time in seconds should this chorus kid's singing fade out?"),
new Param("fade", new EntityTypes.Float(0, 20f, 0f), "Left Chorus Kid", "Set how long (in seconds) this chorus kid's singing should take to fade out if it is interrupted by a game switch."),
new Param("fade1", new EntityTypes.Float(0, 20f, 0f), "Middle Chorus Kid", "Set how long (in seconds) this chorus kid's singing should take to fade out if it is interrupted by a game switch."),
new Param("fadeP", new EntityTypes.Float(0, 20f, 0f), "Player Chorus Kid", "Set how long (in seconds) this chorus kid's singing should take to fade out if it is interrupted by a game switch."),
}
},
new GameAction("passTurn", "Pass Turn")

126
Assets/Scripts/Games/KarateMan/KarateMan.cs
View file

@ -104,8 +104,8 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("toggle2", true, "Bop", "Whether to bop to the beat or not"),
new Param("toggle", false, "Bop (Auto)", "Whether to auto bop to the beat or not")
new Param("toggle2", true, "Bop", "Toggle if Karate Joe should bop for the duration of this event."),
new Param("toggle", false, "Bop (Auto)", "Toggle if Karate Joe should automatically bop until another Bop event is reached.")
},
},
new GameAction("hit", "Toss Object") {
@ -122,9 +122,9 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 2,
parameters = new List<Param>()
{
new Param("type", KarateMan.HitType.Pot, "Object", "The object to fire"),
new Param("type2", KarateMan.KarateManFaces.Normal, "Success Expression", "The facial expression to set Joe to on hit"),
new Param("mute", false, "Mute", "Should the throwing sound be muted?"),
new Param("type", KarateMan.HitType.Pot, "Object", "Choose the object to throw."),
new Param("type2", KarateMan.KarateManFaces.Normal, "Success Expression", "Set the facial expression for Karate Joe to show if he hits the object."),
new Param("mute", false, "Mute", "Toggle if the cue should be muted."),
}
},
new GameAction("bulb", "Toss Lightbulb")
@ -142,22 +142,22 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 2,
parameters = new List<Param>()
{
new Param("type", KarateMan.LightBulbType.Normal, "Type", "The preset bulb type. Yellow is used for kicks while Blue is used for combos", new List<Param.CollapseParam>()
new Param("type", KarateMan.LightBulbType.Normal, "Type", "Choose the bulb type. Yellow is used for kicks, while Blue is used for combos", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (int)x == (int)KarateMan.LightBulbType.Custom, new string[] { "colorA" })
}),
new Param("colorA", new Color(1f,1f,1f), "Custom Color", "The color to use when the bulb type is set to Custom"),
new Param("type2", KarateMan.KarateManFaces.Normal, "Success Expression", "The facial expression to set Joe to on hit"),
new Param("mute", false, "Mute", "Should the throwing sound be muted?"),
new Param("sfx", KarateMan.LightBulbSfx.Automatic, "SFX", "What type of SFX to use for the bulb?", new List<Param.CollapseParam>()
new Param("colorA", new Color(1f,1f,1f), "Custom Color", "Choose the color to use."),
new Param("type2", KarateMan.KarateManFaces.Normal, "Success Expression", "Set the facial expression for Karate Joe to show if he hits the object."),
new Param("mute", false, "Mute", "Toggle if the cue should be muted."),
new Param("sfx", KarateMan.LightBulbSfx.Automatic, "SFX", "Choose the type of SFX to use for the bulb.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (int)x == (int)KarateMan.LightBulbSfx.Custom, new string[] { "throwSfx", "hitSfx" }),
}),
new Param("throwSfx", "lightbulbOut", "Throw SFX", "Custom throw SFX to use for the bulb"),
new Param("hitSfx", "lightbulbHit", "Hit SFX", "Custom hit SFX to use for the bulb"),
new Param("throwSfx", "lightbulbOut", "Throw SFX", "Choose the type of SFX to use for throwing the bulb."),
new Param("hitSfx", "lightbulbHit", "Hit SFX", "Choose the type of SFX to use for hitting the bulb."),
},
},
new GameAction("kick", "Special: Kick")
new GameAction("kick", "Kick")
{
function = delegate {
var e = eventCaller.currentEntity;
@ -172,21 +172,21 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 4f,
parameters = new List<Param>()
{
new Param("toggle", false, "Contains Ball", "Barrel contains a ball instead of a bomb?"),
new Param("shouldGlow", true, "Bomb Glow", "Should Joe be lit up by the bomb in the barrel?"),
new Param("type", KarateMan.KarateManFaces.Smirk, "Success Expression", "The facial expression to set Joe to on hit"),
new Param("pitchVoice", false, "Pitch Voice", "Pitch the voice of this cue?", new List<Param.CollapseParam>()
new Param("toggle", false, "Ball", "Toggle if the barrel should contain a ball instead of a bomb."),
new Param("shouldGlow", true, "Bomb Glow", "Toggle if Joe should be lit up by the bomb in the barrel."),
new Param("type", KarateMan.KarateManFaces.Smirk, "Success Expression", "Set the facial expression for Karate Joe to show if he hits the object."),
new Param("pitchVoice", false, "Pitch Voice", "Toggle if the voice should be pitched.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (bool)x, new string[] { "forcePitch" }),
}),
new Param("forcePitch", new EntityTypes.Float(0.5f, 2f, 1f), "Force Pitch", "Override the automatic pitching if not set to 1"),
new Param("cutOut", true, "Cut Out Voice", "Will this cue be cut out by another voice?"),
new Param("disableVoice", false, "Disable Voice", "When enabled, there will be no voice during this cue"),
new Param("woodColor", new Color(0.451f, 0.302f, 0.271f), "Barrel Wood Color", "Color of the barrel's wood"),
new Param("hoopColor", new Color(0.714f, 0.309f, 0.424f), "Barrel Hoop Color", "Color of the barrel's hoops"),
new Param("forcePitch", new EntityTypes.Float(0.5f, 2f, 1f), "Force Pitch", "Set the pitching of the voice, or keep it at 1 for automatic pitching."),
new Param("cutOut", true, "Cut Out Voice", "Toggle if this cue will be cut out if another voiced cue plays."),
new Param("disableVoice", false, "Mute Voice", "Toggle if the voice should be muted."),
new Param("woodColor", new Color(0.451f, 0.302f, 0.271f), "Barrel Wood Color", "Choose the color of the barrel's wood."),
new Param("hoopColor", new Color(0.714f, 0.309f, 0.424f), "Barrel Hoop Color", "Choose the color of the barrel's hoops."),
}
},
new GameAction("combo", "Special: Combo")
new GameAction("combo", "Combo")
{
function = delegate {
var e = eventCaller.currentEntity;
@ -201,17 +201,17 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 4,
parameters = new List<Param>()
{
new Param("type", KarateMan.KarateManFaces.Happy, "Success Expression", "The facial expression to set Joe to on hit"),
new Param("pitchVoice", false, "Pitch Voice", "Pitch the voice of this cue", new List<Param.CollapseParam>()
new Param("type", KarateMan.KarateManFaces.Happy, "Success Expression", "Set the facial expression for Karate Joe to show if he hits the object."),
new Param("pitchVoice", false, "Pitch Voice", "Toggle if the voice should be pitched.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (bool)x, new string[] { "forcePitch" }),
}),
new Param("forcePitch", new EntityTypes.Float(0.5f, 2f, 1f), "Force Pitch", "Override the automatic pitching if not set to 1"),
new Param("cutOut", true, "Cut Out Voice", "Will this cue be cut out by another voice?"),
new Param("disableVoice", false, "Disable Voice", "When enabled, there will be no voice during this cue"),
new Param("forcePitch", new EntityTypes.Float(0.5f, 2f, 1f), "Force Pitch", "Set the pitching of the voice, or keep it at 1 for automatic pitching."),
new Param("cutOut", true, "Cut Out Voice", "Toggle if this cue will be cut out if another voiced cue plays."),
new Param("disableVoice", false, "Mute Voice", "Toggle if the voice should be muted."),
}
},
new GameAction("warnings", "Warnings")
new GameAction("warnings", "Text Warnings")
{
function = delegate {
var e = eventCaller.currentEntity;
@ -221,14 +221,14 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("whichWarning", KarateMan.HitThree.HitThree, "Which Warning", "The warning text to show and the sfx to play"),
new Param("pitchVoice", false, "Pitch Voice", "Pitch the voice of this cue", new List<Param.CollapseParam>()
new Param("whichWarning", KarateMan.HitThree.HitThree, "Warning", "Choose the warning text to show and the sfx to play."),
new Param("pitchVoice", false, "Pitch Voice", "Toggle if the voice should be pitched.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (bool)x, new string[] { "forcePitch" }),
}),
new Param("forcePitch", new EntityTypes.Float(0.5f, 2f, 1f), "Force Pitch", "Override the automatic pitching if not set to 1"),
new Param("customLength", false, "Custom Length", "Have the warning text appear for the length of the block"),
new Param("cutOut", true, "Cut Out Voice", "Will this cue be cut out by another voice?"),
new Param("forcePitch", new EntityTypes.Float(0.5f, 2f, 1f), "Force Pitch", "Set the pitching of the voice, or keep it at 1 for automatic pitching."),
new Param("customLength", false, "Stretchable Length", "Toggle if the text should appear for the entire length of the event."),
new Param("cutOut", true, "Cut Out Voice", "Toggle if this cue will be cut out if another voiced cue plays."),
},
inactiveFunction = delegate {
var e = eventCaller.currentEntity;
@ -242,11 +242,11 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("toggle", true, "Return Camera", "Camera zooms back in?"),
new Param("toggle", true, "Return Camera", "Toggle if the camera should zoom back in."),
},
inactiveFunction = delegate { var e = eventCaller.currentEntity; KarateMan.DoSpecialCamera(e.beat, e.length, e["toggle"]); }
},
new GameAction("prepare", "Preparation Stance")
new GameAction("prepare", "Prepare")
{
function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.Prepare(e.beat, e.length);},
resizable = true,
@ -260,10 +260,10 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("fxType", KarateMan.BackgroundFXType.None, "FX Type", "The background effect to be displayed"),
new Param("type", KarateMan.NoriMode.None, "Flow Bar type", "The type of Flow bar to use"),
new Param("fxType", KarateMan.BackgroundFXType.None, "FX Type", "Set the background effect to be displayed."),
new Param("type", KarateMan.NoriMode.None, "Flow Bar", "Set the type of Flow bar to use."),
// new Param("hitsPerHeart", new EntityTypes.Float(0f, 20f, 0f), "Hits Per Heart", "How many hits it will take for each heart to light up (0 will do it automatically.)"),
new Param("toggle", true, "Enable Combos", "Allow the player to combo? (Contextual combos will still be allowed even when off)"),
new Param("toggle", true, "Enable Combos", "Toggle if Karate Joe will be able to perform combos. This will not affect Touch Style controls."),
// new Param("toggle2", true, "Enable Kicks", "Allow the player to kick? (Contextual kicks will still be allowed even when off)"),
},
},
@ -282,32 +282,32 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>() // uncomment these collapses when overlapping collapses are implemented
{
new Param("presetBg", KarateMan.BackgroundType.Yellow, "Preset BG Color", "The preset background type (will by default fade from the existing background color)", new List<Param.CollapseParam>()
new Param("presetBg", KarateMan.BackgroundType.Yellow, "BG Color", "Set the background type. This will fade from the existing background color for the length of the event..", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (int)x == (int)KarateMan.BackgroundType.Custom, new string[] { "startColor", "endColor" }),
}),
new Param("startColor", new Color(0.985f, 0.79f, 0.243f), "Start BG Color", "The background color to start with"),
new Param("endColor", new Color(0.985f, 0.79f, 0.243f), "End BG Color", "The background color to end with"),
new Param("ease", Util.EasingFunction.Ease.Instant, "BG Color Ease", "Ease to use when fading color"),
new Param("shadowType", KarateMan.ShadowType.Tinted, "Shadow Type", "The shadow type. If Tinted doesn't work with your background color try Custom", new List<Param.CollapseParam>()
new Param("startColor", new Color(0.985f, 0.79f, 0.243f), "Start BG Color", "Set the color at the start of the event."),
new Param("endColor", new Color(0.985f, 0.79f, 0.243f), "End BG Color", "Set the color at the end of the event."),
new Param("ease", Util.EasingFunction.Ease.Instant, "Ease", "Set the easing of the action."),
new Param("shadowType", KarateMan.ShadowType.Tinted, "Shadow", "Set the shadow type. If Tinted doesn't work with your background color, try Custom.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (int)x == (int)KarateMan.ShadowType.Custom, new string[] { "shadowStart", "shadowEnd" }),
}),
new Param("shadowStart", new Color(), "Start Shadow Color", "The shadow color to start with"),
new Param("shadowEnd", new Color(), "End Shadow Color", "The shadow color to end with"),
new Param("shadowStart", new Color(), "Start Shadow Color", "Set the color at the start of the event."),
new Param("shadowEnd", new Color(), "End Shadow Color", "Set the color at the end of the event."),
new Param("fxType", KarateMan.BackgroundFXType.None, "FX Type", "The background effect to be displayed"),
new Param("fxType", KarateMan.BackgroundFXType.None, "FX Type", "Set the background effect to be displayed."),
new Param("textureType", KarateMan.BackgroundTextureType.Plain, "Texture", "The type of background texture to use", new List<Param.CollapseParam>()
new Param("textureType", KarateMan.BackgroundTextureType.Plain, "Texture", "Set the type of background texture to use", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (int)x != (int)KarateMan.BackgroundTextureType.Plain, new string[] { "startTexture", "endTexture" })
}),
new Param("autoColor", true, "Use BG Color For Texture", "Use a tint of the background color for the texture?", new List<Param.CollapseParam>()
new Param("autoColor", true, "Use BG Color For Texture", "Toggle if the texture should use a tint of the BG Color.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => !(bool)x, new string[] { "startTexture", "endTexture" })
}),
new Param("startTexture", new Color(), "Start Texture Color", "The texture color to start with"),
new Param("endTexture", new Color(), "End Texture Color", "The texture color to end with"),
new Param("startTexture", new Color(), "Start Texture Color", "Set the color at the start of the event."),
new Param("endTexture", new Color(), "End Texture Color", "Set the color at the end of the event."),
},
},
// new GameAction("set background effects", "Background Appearance (OLD)")
@ -332,7 +332,7 @@ namespace HeavenStudio.Games.Loaders
// new Param("colorD", new Color(), "Fading Filter Color", "When using the Fade background effect, make filter colour fade to this colour"),
// },
// },
new GameAction("set object colors", "Object Colors")
new GameAction("set object colors", "Object Appearance")
{
function = delegate {
var e = eventCaller.currentEntity;
@ -341,14 +341,14 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("colorA", new Color(1,1,1,1), "Joe Body Color", "The color to use for Karate Joe's body"),
new Param("colorB", new Color(0.81f,0.81f,0.81f,1), "Joe Highlight Color", "The color to use for Karate Joe's highlights"),
new Param("colorC", new Color(1,1,1,1), "Item Color", "The color to use for the thrown items"),
new Param("star", KarateMan.StarColorOption.ItemColor, "Star Color Options", "", new()
new Param("colorA", new Color(1,1,1,1), "Joe Body Color", "Set the color to use for Karate Joe's body."),
new Param("colorB", new Color(0.81f,0.81f,0.81f,1), "Joe Highlight Color", "Set the color to use for Karate Joe's highlights."),
new Param("colorC", new Color(1,1,1,1), "Item Color", "Set the color to use for the thrown items."),
new Param("star", KarateMan.StarColorOption.ItemColor, "Star Color Options", "Set if the color of the stars that appear on hit should be based on the item color.", new()
{
new((x, _) => (int)x == (int)KarateMan.StarColorOption.Custom, new string[] { "colorD" })
}),
new Param("colorD", new Color(1,1,1,1), "Star Color", "The color to use for star particles"),
new Param("colorD", new Color(1,1,1,1), "Star Color", "Set the color to use for star particles."),
},
},
new GameAction("particle effects", "Particle Effects")
@ -360,20 +360,20 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("type", KarateMan.ParticleType.None, "Particle Type", "The type of particle effect to spawn. Using \"None\" will stop all effects"),
new Param("instant", false, "Instant", "Start/Stop particles instantly"),
new Param("valA", new EntityTypes.Float(0f, 64f, 1f), "Wind Strength", "The strength of the particle wind"),
new Param("valB", new EntityTypes.Float(1f, 16f, 1f), "Particle Intensity", "The intensity of the particle effect")
new Param("type", KarateMan.ParticleType.None, "Particle", "Set the type of particle effect to spawn. Using \"None\" will stop all effects."),
new Param("instant", false, "Instant", "Toggle if the particles should start or stop instantly."),
new Param("valA", new EntityTypes.Float(0f, 64f, 1f), "Wind Strength", "Set the strength of the particle wind."),
new Param("valB", new EntityTypes.Float(1f, 16f, 1f), "Particle Intensity", "Set the intensity of the particle effect.")
},
},
new GameAction("force facial expression", "Set Facial Expression")
new GameAction("force facial expression", "Facial Expression")
{
function = delegate { KarateMan.instance.SetFaceExpression(eventCaller.currentEntity["type"]); },
defaultLength = 0.5f,
resizable = true,
parameters = new List<Param>()
{
new Param("type", KarateMan.KarateManFaces.Normal, "Facial Expression", "The facial expression to force Joe to. Special moves may override this")
new Param("type", KarateMan.KarateManFaces.Normal, "Facial Expression", "Set the facial expression to force Karate Joe to. Special moves may override this.")
}
},

1
Assets/Scripts/Games/KarateMan/KarateManJoe.cs
View file

@ -153,7 +153,6 @@ namespace HeavenStudio.Games.Scripts_KarateMan
{
if (PlayerInput.CurrentControlStyle == InputController.ControlStyles.Touch)
{
Debug.Log("Touch charge");
inTouchCharge = true;
anim.DoScaledAnimationAsync("ManChargeOut", 0.5f);
}

1
Assets/Scripts/Games/KarateMan/KarateManPot.cs
View file

@ -1097,7 +1097,6 @@ namespace HeavenStudio.Games.Scripts_KarateMan
public bool CanKick()
{
var joe = KarateMan.instance.Joe;
Debug.Log(joe.inKick);
return status == FlyStatus.Fly && joe.inKick;
}

26
Assets/Scripts/Games/Kitties/Kitties.cs
View file

@ -21,10 +21,10 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 4f,
parameters = new List<Param>()
{
new Param("type", Kitties.SpawnType.Straight, "Spawn", "The way in which the kitties will spawn"),
new Param("toggle", false, "Mice", "Replaces kitties as mice"),
new Param("toggle1", false, "Invert Direction", "Inverts the direction they clap in"),
new Param("toggle2", false, "Keep Cats Spawned", "Sets whether or not cats stay spawned after their cue"),
new Param("type", Kitties.SpawnType.Straight, "Direction", "Choose the direction that the kitties will spawn in."),
new Param("toggle", false, "Mice", "Toggle if the non-player kitties should be replaced with mice."),
new Param("toggle1", false, "Invert Direction", "Toggle if the spawn direction should be inverted."),
new Param("toggle2", false, "Keep Cats Spawned", "Toggle if the kitties should stay spawned after their cue. This is required for some other events."),
}
},
@ -36,7 +36,7 @@ namespace HeavenStudio.Games.Loaders
parameters = new List<Param>()
{
new Param("toggle", false, "Keep Cats spawned", "Sets whether or not cats stay spawned after their cue"),
new Param("toggle", false, "Keep Cats Spawned", "Toggle if the kitties should stay spawned after their cue. This is required for some other events."),
}
},
@ -54,14 +54,14 @@ namespace HeavenStudio.Games.Loaders
defaultLength = .5f,
parameters = new List<Param>()
{
new Param("type", Kitties.SpawnType.Straight, "Spawn", "The way in which the kitties will spawn"),
new Param("toggle", false, "Mice", "Replaces kitties as mice"),
new Param("toggle1", false, "Invert Direction", "Inverts the direction they clap in"),
new Param("toggle2", false, "Keep Cats Spawned", "Sets whether or not cats stay spawned after their cue"),
new Param("type", Kitties.SpawnType.Straight, "Direction", "Choose the direction that the kitties will spawn in."),
new Param("toggle", false, "Mice", "Toggle if the non-player kitties should be replaced with mice."),
new Param("toggle1", false, "Invert Direction", "Toggle if the spawn direction should be inverted."),
new Param("toggle2", false, "Keep Cats Spawned", "Toggle if the kitties should stay spawned after their cue. This is required for some other events."),
}
},
new GameAction("bgcolor", "Background Color")
new GameAction("bgcolor", "Background Appearance")
{
function = delegate
{
@ -72,9 +72,9 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("colorStart", Color.white, "Start Color"),
new Param("colorEnd", Color.white, "End Color"),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease")
new Param("colorStart", Color.white, "Start Color", "Set the color at the start of the event."),
new Param("colorEnd", Color.white, "End Color", "Set the color at the end of the event."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.")
}
}
},

110
Assets/Scripts/Games/LaunchParty/LaunchParty.cs
View file

@ -19,11 +19,11 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 4f,
parameters = new List<Param>()
{
new Param("offset", new EntityTypes.Float(-1, 2, -1), "Spawn Offset", "When should the rocket rise up?"),
new Param("note1", new EntityTypes.Integer(-24, 24, 2), "1st Note", "The number of semitones up or down this note should be pitched"),
new Param("note2", new EntityTypes.Integer(-24, 24, 4), "2nd Note", "The number of semitones up or down this note should be pitched"),
new Param("note3", new EntityTypes.Integer(-24, 24, 5), "3rd Note", "The number of semitones up or down this note should be pitched"),
new Param("note4", new EntityTypes.Integer(-24, 24, 7), "4th Note", "The number of semitones up or down this note should be pitched")
new Param("offset", new EntityTypes.Float(-1, 2, -1), "Spawn Offset", "Set when the rocket should rise up."),
new Param("note1", new EntityTypes.Integer(-24, 24, 2), "1st Note", "Set the number of semitones up or down this note should be pitched."),
new Param("note2", new EntityTypes.Integer(-24, 24, 4), "2nd Note", "Set the number of semitones up or down this note should be pitched."),
new Param("note3", new EntityTypes.Integer(-24, 24, 5), "3rd Note", "Set the number of semitones up or down this note should be pitched."),
new Param("note4", new EntityTypes.Integer(-24, 24, 7), "4th Note", "Set the number of semitones up or down this note should be pitched.")
}
},
new GameAction("partyCracker", "Party-Popper")
@ -32,13 +32,13 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 3f,
parameters = new List<Param>()
{
new Param("offset", new EntityTypes.Float(-1, 1, -1), "Spawn Offset", "When should the rocket rise up?"),
new Param("note1", new EntityTypes.Integer(-24, 24, 4), "1st Note", "The number of semitones up or down this note should be pitched"),
new Param("note2", new EntityTypes.Integer(-24, 24, 5), "2nd Note", "The number of semitones up or down this note should be pitched"),
new Param("note3", new EntityTypes.Integer(-24, 24, 7), "3rd Note", "The number of semitones up or down this note should be pitched"),
new Param("note4", new EntityTypes.Integer(-24, 24, 9), "4th Note", "The number of semitones up or down this note should be pitched"),
new Param("note5", new EntityTypes.Integer(-24, 24, 11), "5th Note", "The number of semitones up or down this note should be pitched"),
new Param("note6", new EntityTypes.Integer(-24, 24, 12), "6th Note", "The number of semitones up or down this note should be pitched")
new Param("offset", new EntityTypes.Float(-1, 1, -1), "Spawn Offset", "Set when the rocket should rise up."),
new Param("note1", new EntityTypes.Integer(-24, 24, 4), "1st Note", "Set the number of semitones up or down this note should be pitched."),
new Param("note2", new EntityTypes.Integer(-24, 24, 5), "2nd Note", "Set the number of semitones up or down this note should be pitched."),
new Param("note3", new EntityTypes.Integer(-24, 24, 7), "3rd Note", "Set the number of semitones up or down this note should be pitched."),
new Param("note4", new EntityTypes.Integer(-24, 24, 9), "4th Note", "Set the number of semitones up or down this note should be pitched."),
new Param("note5", new EntityTypes.Integer(-24, 24, 11), "5th Note", "Set the number of semitones up or down this note should be pitched."),
new Param("note6", new EntityTypes.Integer(-24, 24, 12), "6th Note", "Set the number of semitones up or down this note should be pitched.")
}
},
new GameAction("bell", "Bell")
@ -48,16 +48,16 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 3f,
parameters = new List<Param>()
{
new Param("offset", new EntityTypes.Float(-1, 1, -1), "Spawn Offset", "When should the rocket rise up?"),
new Param("note1", new EntityTypes.Integer(-24, 24, 0), "1st Note", "The number of semitones up or down this note should be pitched"),
new Param("note2", new EntityTypes.Integer(-24, 24, 2), "2nd Note", "The number of semitones up or down this note should be pitched"),
new Param("note3", new EntityTypes.Integer(-24, 24, 4), "3rd Note", "The number of semitones up or down this note should be pitched"),
new Param("note4", new EntityTypes.Integer(-24, 24, 5), "4th Note", "The number of semitones up or down this note should be pitched"),
new Param("note5", new EntityTypes.Integer(-24, 24, 7), "5th Note", "The number of semitones up or down this note should be pitched"),
new Param("note6", new EntityTypes.Integer(-24, 24, 9), "6th Note", "The number of semitones up or down this note should be pitched"),
new Param("note7", new EntityTypes.Integer(-24, 24, 11), "7th Note", "The number of semitones up or down this note should be pitched"),
new Param("note8", new EntityTypes.Integer(-24, 24, 12), "8th Note", "The number of semitones up or down this note should be pitched"),
new Param("note9", new EntityTypes.Integer(-24, 24, 0), "9th Note (Launch)", "The number of semitones up or down this note should be pitched"),
new Param("offset", new EntityTypes.Float(-1, 1, -1), "Spawn Offset", "Set when the rocket should rise up."),
new Param("note1", new EntityTypes.Integer(-24, 24, 0), "1st Note", "Set the number of semitones up or down this note should be pitched."),
new Param("note2", new EntityTypes.Integer(-24, 24, 2), "2nd Note", "Set the number of semitones up or down this note should be pitched."),
new Param("note3", new EntityTypes.Integer(-24, 24, 4), "3rd Note", "Set the number of semitones up or down this note should be pitched."),
new Param("note4", new EntityTypes.Integer(-24, 24, 5), "4th Note", "Set the number of semitones up or down this note should be pitched."),
new Param("note5", new EntityTypes.Integer(-24, 24, 7), "5th Note", "Set the number of semitones up or down this note should be pitched."),
new Param("note6", new EntityTypes.Integer(-24, 24, 9), "6th Note", "Set the number of semitones up or down this note should be pitched."),
new Param("note7", new EntityTypes.Integer(-24, 24, 11), "7th Note", "Set the number of semitones up or down this note should be pitched."),
new Param("note8", new EntityTypes.Integer(-24, 24, 12), "8th Note", "Set the number of semitones up or down this note should be pitched."),
new Param("note9", new EntityTypes.Integer(-24, 24, 0), "9th Note (Launch)", "Set the number of semitones up or down this note should be pitched."),
}
},
new GameAction("bowlingPin", "Bowling Pin")
@ -67,21 +67,21 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 3f,
parameters = new List<Param>()
{
new Param("offset", new EntityTypes.Float(-1, 1, -1), "Spawn Offset", "When should the rocket rise up?"),
new Param("note1", new EntityTypes.Integer(-24, 24, 5), "1st Note", "The number of semitones up or down this note should be pitched"),
new Param("note2", new EntityTypes.Integer(-24, 24, -1), "2nd Note (Flute)", "The number of semitones up or down this note should be pitched"),
new Param("note3", new EntityTypes.Integer(-24, 24, 0), "3rd Note (Flute)", "The number of semitones up or down this note should be pitched"),
new Param("note4", new EntityTypes.Integer(-24, 24, -1), "4th Note (Flute)", "The number of semitones up or down this note should be pitched"),
new Param("note5", new EntityTypes.Integer(-24, 24, 0), "5th Note (Flute)", "The number of semitones up or down this note should be pitched"),
new Param("note6", new EntityTypes.Integer(-24, 24, -1), "6th Note (Flute)", "The number of semitones up or down this note should be pitched"),
new Param("note7", new EntityTypes.Integer(-24, 24, 0), "7th Note (Flute)", "The number of semitones up or down this note should be pitched"),
new Param("note8", new EntityTypes.Integer(-24, 24, -1), "8th Note (Flute)", "The number of semitones up or down this note should be pitched"),
new Param("note9", new EntityTypes.Integer(-24, 24, 0), "9th Note (Flute)", "The number of semitones up or down this note should be pitched"),
new Param("note10", new EntityTypes.Integer(-24, 24, -1), "10th Note (Flute)", "The number of semitones up or down this note should be pitched"),
new Param("note11", new EntityTypes.Integer(-24, 24, 0), "11th Note (Flute)", "The number of semitones up or down this note should be pitched"),
new Param("note12", new EntityTypes.Integer(-24, 24, -1), "12th Note (Flute)", "The number of semitones up or down this note should be pitched"),
new Param("note13", new EntityTypes.Integer(-24, 24, 0), "13th Note (Flute)", "The number of semitones up or down this note should be pitched"),
new Param("note14", new EntityTypes.Integer(-24, 24, 7), "14th Note (Flute)", "The number of semitones up or down this note should be pitched"),
new Param("offset", new EntityTypes.Float(-1, 1, -1), "Spawn Offset", "Set when the rocket should rise up."),
new Param("note1", new EntityTypes.Integer(-24, 24, 5), "1st Note", "Set the number of semitones up or down this note should be pitched."),
new Param("note2", new EntityTypes.Integer(-24, 24, -1), "2nd Note (Flute)", "Set the number of semitones up or down this note should be pitched."),
new Param("note3", new EntityTypes.Integer(-24, 24, 0), "3rd Note (Flute)", "Set the number of semitones up or down this note should be pitched."),
new Param("note4", new EntityTypes.Integer(-24, 24, -1), "4th Note (Flute)", "Set the number of semitones up or down this note should be pitched."),
new Param("note5", new EntityTypes.Integer(-24, 24, 0), "5th Note (Flute)", "Set the number of semitones up or down this note should be pitched."),
new Param("note6", new EntityTypes.Integer(-24, 24, -1), "6th Note (Flute)", "Set the number of semitones up or down this note should be pitched."),
new Param("note7", new EntityTypes.Integer(-24, 24, 0), "7th Note (Flute)", "Set the number of semitones up or down this note should be pitched."),
new Param("note8", new EntityTypes.Integer(-24, 24, -1), "8th Note (Flute)", "Set the number of semitones up or down this note should be pitched."),
new Param("note9", new EntityTypes.Integer(-24, 24, 0), "9th Note (Flute)", "Set the number of semitones up or down this note should be pitched."),
new Param("note10", new EntityTypes.Integer(-24, 24, -1), "10th Note (Flute)", "Set the number of semitones up or down this note should be pitched."),
new Param("note11", new EntityTypes.Integer(-24, 24, 0), "11th Note (Flute)", "Set the number of semitones up or down this note should be pitched."),
new Param("note12", new EntityTypes.Integer(-24, 24, -1), "12th Note (Flute)", "Set the number of semitones up or down this note should be pitched."),
new Param("note13", new EntityTypes.Integer(-24, 24, 0), "13th Note (Flute)", "Set the number of semitones up or down this note should be pitched."),
new Param("note14", new EntityTypes.Integer(-24, 24, 7), "14th Note (Flute)", "Set the number of semitones up or down this note should be pitched."),
new Param("note15", new EntityTypes.Integer(-24, 24, 7), "15th Note", "The number of semitones up or down this note should be pitched")
}
},
@ -91,10 +91,10 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("xPos", new EntityTypes.Float(-40f, 40f, 0f), "X Position", "Which position on the X axis should the Launch Pad travel to?"),
new Param("yPos", new EntityTypes.Float(-30f, 30f, 0f), "Y Position", "Which position on the Y axis should the Launch Pad travel to?"),
new Param("zPos", new EntityTypes.Float(-90f, 90f, 0f), "Z Position", "Which position on the Z axis should the Launch Pad travel to?"),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Which ease should the Launch Pad use?")
new Param("xPos", new EntityTypes.Float(-40f, 40f, 0f), "X Position", "Set the position on the X axis that the Launch Pad should travel to."),
new Param("yPos", new EntityTypes.Float(-30f, 30f, 0f), "Y Position", "Set the position on the Y axis that the Launch Pad should travel to."),
new Param("zPos", new EntityTypes.Float(-90f, 90f, 0f), "Z Position", "Set the position on the Z axis that the Launch Pad should travel to."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.")
}
},
new GameAction("rotMove", "Change Launch Pad Rotation")
@ -104,9 +104,35 @@ namespace HeavenStudio.Games.Loaders
parameters = new List<Param>()
{
new Param("rot", new EntityTypes.Float(-360, 360, 0), "Angle", "Which angle of rotation should the Launch Pad rotate towards?"),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Which ease should the Launch Pad use?")
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.")
}
},
new GameAction("toggleStars", "Falling Stars")
{
// function = delegate {var e = eventCaller.currentEntity; LaunchParty.instance.CreateParticles(e.beat, e["toggle"], e["valA"], e["valB"], e["valC"]);},
hidden = true,
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("toggle", true, "Stars", "Toggle if stars should fall from the top of the screen.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (bool)x, new string[] { "valA", "valB", "valC"})
}),
new Param("valA", new EntityTypes.Float(0.1f, 10f, 1f), "Star Density", "Set how many stars are spawned."),
new Param("valB", new EntityTypes.Float(0.01f, 5f, 0.1f), "Front Star Fall Speed", "Set how fast the front stars fall to the bottom edge of the screen."),
new Param("valC", new EntityTypes.Float(0.01f, 5f, 0.1f), "Back Star Fall Speed", "Set how fast the stars fall to the bottom edge of the screen.")
}
},
new GameAction("scrollSpeed", "Scroll Speed")
{
// function = delegate {var e = eventCaller.currentEntity; LaunchParty.instance.UpdateScrollSpeed(e["speed"]); },
hidden = true,
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("speed", new EntityTypes.Float(0, 100, 0.5f), "Scroll Speed", "Set how fast the background will scroll down."),
}
}
},
new List<string>() {"rvl", "normal"},
"rvlrocket", "en",

44
Assets/Scripts/Games/Lockstep/Lockstep.cs
View file

@ -26,8 +26,8 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("toggle", true, "Bop", "Should the stepswitchers bop?"),
new Param("toggle2", false, "Bop (Auto)", "Should the stepswitchers auto bop?"),
new Param("toggle", true, "Bop", "Toggle if the stepswitchers should bop for the duration of this event."),
new Param("toggle2", false, "Bop (Auto)", "Toggle if the stepswitchers should automatically bop until another Bop event is reached."),
},
},
new GameAction("stepping", "Stepping")
@ -35,12 +35,12 @@ namespace HeavenStudio.Games.Loaders
preFunction = delegate {var e = eventCaller.currentEntity; Lockstep.Marching(e.beat, e["sound"], e["amount"], e["visual"]);},
parameters = new List<Param>()
{
new Param("sound", false, "Sound", "Hai if onbeat, ho if offbeat.", new List<Param.CollapseParam>()
new Param("sound", false, "Voice", "Toggle if voice sounds should play automatically when stepping starts. It will automatically switch between \"Hai!\" and \"Ho!\" if it is on or off beat.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (bool)x, new string[] { "amount" })
}),
new Param("amount", new EntityTypes.Integer(1, 50, 1), "Sound Amount", "How many sounds will play consecutively?"),
new Param("visual", true, "Background Visual")
new Param("amount", new EntityTypes.Integer(1, 50, 1), "Amount", "Set how many sounds will play."),
new Param("visual", true, "Background Visual", "Toggle if the background will automatically flip depending on if it's on or off beat.")
},
preFunctionLength = 1
},
@ -50,9 +50,9 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 4.5f,
parameters = new List<Param>()
{
new Param("sound", true, "Sound Cue"),
new Param("ho", true, "Ho Sounds", "Will the <ho, ho, ho, ho> sound be present?"),
new Param("visual", true, "Background Visual")
new Param("sound", true, "Sound Cue", "Toggle if the \"Hai! Hai! Hai! Ha-Ha!\" sound should be played."),
new Param("ho", true, "End Sounds", "Toggle if the \"Ho! Ho! Ho! Ho!\" sound should be played."),
new Param("visual", true, "Background Visual", "Toggle if the background will automatically flip depending on if it's on or off beat.")
}
},
new GameAction("onbeatSwitch", "Switch to Onbeat")
@ -61,9 +61,9 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 3f,
parameters = new List<Param>()
{
new Param("sound", true, "Sound Cue"),
new Param("hai", new EntityTypes.Integer(0, 100, 1), "Hai Amount"),
new Param("visual", true, "Background Visual")
new Param("sound", true, "Sound Cue", "Toggle if the \"Mm-ha! Mm-ha! Hai!\" sound should be played."),
new Param("hai", new EntityTypes.Integer(0, 100, 1), "Set how many \"Hai!\" sounds will play."),
new Param("visual", true, "Background Visual", "Toggle if the background will automatically flip depending on if it's on or off beat.")
}
},
new GameAction("hai", "Hai")
@ -74,25 +74,25 @@ namespace HeavenStudio.Games.Loaders
{
preFunction = delegate { Lockstep.HoSound(eventCaller.currentEntity.beat); }
},
new GameAction("set colours", "Set Colours")
new GameAction("set colours", "Set Colors")
{
function = delegate {var e = eventCaller.currentEntity; Lockstep.instance.SetBackgroundColours(e["colorA"], e["colorB"], e["objColA"], e["objColB"], e["objColC"]); },
parameters = new List<Param>()
{
new Param("colorA", Lockstep.defaultBGColorOn, "Background Onbeat", "Select the color that appears for the onbeat."),
new Param("colorB", Lockstep.defaultBGColorOff, "Background Offbeat", "Select the color that appears for the offbeat."),
new Param("objColA", Lockstep.stepperOut, "Stepper Outline", "Select the color used for the outline of the stepswitchers."),
new Param("objColB", Lockstep.stepperDark, "Stepper Dark", "Select the color that appears for the dark side of the stepwitchers."),
new Param("objColC", Lockstep.stepperLight, "Stepper Light", "Select the color that appears for the light side of the stepwitchers."),
new Param("colorA", Lockstep.defaultBGColorOn, "Background Onbeat", "Set the color that appears for the onbeat."),
new Param("colorB", Lockstep.defaultBGColorOff, "Background Offbeat", "Set the color that appears for the offbeat."),
new Param("objColA", Lockstep.stepperOut, "Stepper Outline", "Set the color used for the outline of the stepswitchers."),
new Param("objColB", Lockstep.stepperDark, "Stepper Dark", "Set the color that appears for the dark side of the stepwitchers."),
new Param("objColC", Lockstep.stepperLight, "Stepper Light", "Set the color that appears for the light side of the stepwitchers."),
},
defaultLength = 0.5f,
},
new GameAction("zoom", "Preset Zooms")
new GameAction("zoom", "Zoom Camera")
{
function = delegate { Lockstep.instance.SetZoom(eventCaller.currentEntity["zoom"]); },
parameters = new List<Param>()
{
new Param("zoom", Lockstep.ZoomPresets.Regular, "Zoom Level")
new Param("zoom", Lockstep.ZoomPresets.Regular, "Zoom Level", "Set the level to zoom to.")
}
},
new GameAction("bach", "Show Bach")
@ -105,12 +105,12 @@ namespace HeavenStudio.Games.Loaders
preFunction = delegate {var e = eventCaller.currentEntity; Lockstep.Marching(e.beat, e["sound"], e["amount"], e["visual"], true, e.length);},
parameters = new List<Param>()
{
new Param("sound", false, "Sound", "Hai if onbeat, ho if offbeat.", new List<Param.CollapseParam>()
new Param("sound", false, "Voice", "Toggle if voice sounds should play automatically when stepping starts. It will automatically switch between \"Hai!\" and \"Ho!\" if it is on or off beat.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (bool)x, new string[] { "amount" })
}),
new Param("amount", new EntityTypes.Integer(1, 50, 1), "Sound Amount", "How many sounds will play consecutively?"),
new Param("visual", true, "Background Visual")
new Param("amount", new EntityTypes.Integer(1, 50, 1), "Amount", "Set how many sounds will play."),
new Param("visual", true, "Background Visual", "Toggle if the background will automatically flip depending on if it's on or off beat."),
},
preFunctionLength = 1,
resizable = true,

44
Assets/Scripts/Games/MarchingOrders/MarchingOrders.cs
View file

@ -60,9 +60,9 @@ namespace HeavenStudio.Games.Loaders
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 Param("clap", false, "Clap", "Should the cadets clap instead of bop?"),
new Param("bop", true, "Bop", "Toggle if the cadets should bop for the duration of this event."),
new Param("autoBop", false, "Bop (Auto)", "Toggle if the cadets should automatically bop until another Bop event is reached."),
new Param("clap", false, "Clap", "Toggle if the cadets should clap instead of bop."),
}
},
new GameAction("attention", "Attention...")
@ -78,8 +78,8 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 2f,
parameters = new List<Param>
{
new Param("disableVoice", false, "Disable Voice", "Disable the Drill Sergeant's call"),
new Param("shouldMarch", true, "March", "Disable automatic marching"),
new Param("disableVoice", false, "Mute Voice", "Toggle if the Sergeant's cue should play."),
new Param("shouldMarch", true, "March", "Toggle if the cadets should automatically march. If not, you should use a \"Force Marching\" event."),
},
priority = 5,
},
@ -92,8 +92,8 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 4f,
parameters = new List<Param>()
{
new Param("direction", MarchingOrders.Direction.Right, "Direction", "The direction for the cadets to face."),
new Param("point", false, "Point", "Point and face a direction instead of just facing a direction."),
new Param("direction", MarchingOrders.Direction.Right, "Direction", "Choose the direction for the cadets to face."),
new Param("point", false, "Point", "Toggle if the cadets should both point and face the direction."),
}
},
new GameAction("faceTurnFast", "Fast Face Turn")
@ -105,8 +105,8 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 3f,
parameters = new List<Param>()
{
new Param("direction", MarchingOrders.Direction.Right, "Direction", "The direction for the cadets to face."),
new Param("point", false, "Point", "Point and face a direction instead of just facing a direction."),
new Param("direction", MarchingOrders.Direction.Right, "Direction", "Choose the direction for the cadets to face."),
new Param("point", false, "Point", "Toggle if the cadets should both point and face the direction."),
}
},
new GameAction("halt", "Halt!")
@ -123,13 +123,13 @@ namespace HeavenStudio.Games.Loaders
},
parameters = new List<Param>()
{
new Param("start", true, "Start Moving", "Start moving the conveyor"),
new Param("direction", MarchingOrders.Direction.Right, "Direction", "The direction the cadets will move"),
new Param("start", true, "Start Moving", "Toggle if the conveyor should start moving."),
new Param("direction", MarchingOrders.Direction.Right, "Direction", "Set the direction the conveyor will move."),
},
defaultLength = 7f,
resizable = true,
},
new GameAction("background", "Background Colors")
new GameAction("background", "Background Appearance")
{
function = delegate {
var e = eventCaller.currentEntity;
@ -138,16 +138,16 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("preset", MarchingOrders.BackgroundColor.Yellow, "Color", "Choose from a preset, or choose custom and set colors below"),
new Param("colorFill", new Color(0.259f, 0.353f, 0.404f), "Wall Color", "Sets the color of the wall"),
new Param("colorTiles1", new Color(1f, 0.76f, 0.52f), "Tile Outline Color", "Sets the color of the tile outline"),
new Param("colorTiles2", new Color(1f, 0.6f, 0.2f), "Tile Shading Color", "Sets the color of the tile shading"),
new Param("colorTiles3", new Color(1f, 0.675f, 0f), "Tile Fill Color", "Sets the color of the tile's main color"),
new Param("colorPipes1", new Color(0.41f, 0.54f, 0.34f), "Pipe Outline Color", "Sets the color of the pipes' outline"),
new Param("colorPipes2", new Color(0.43f, 0.8f, 0.45f), "Pipe Shading Color", "Sets the color of the pipes' shading"),
new Param("colorPipes3", new Color(0.48f, 0.89f, 0.54f), "Pipe Fill Color", "Sets the color of the pipes"),
new Param("colorConveyor1", new Color(0.157f, 0.25f, 0.3f), "Conveyor Fill Color", "Sets the color of the conveyer belt"),
new Param("colorConveyor2", new Color(0.55f, 0.57f, 0.04f), "Conveyor Trim Color", "Sets the conveyor's trim color"),
new Param("preset", MarchingOrders.BackgroundColor.Yellow, "Color", "Set the color of the background."),
new Param("colorFill", new Color(0.259f, 0.353f, 0.404f), "Wall Color", "Set the color of the wall."),
new Param("colorTiles1", new Color(1f, 0.76f, 0.52f), "Tile Outline Color", "Set the color of the tile outline."),
new Param("colorTiles2", new Color(1f, 0.6f, 0.2f), "Tile Shading Color", "Set the color of the tile shading."),
new Param("colorTiles3", new Color(1f, 0.675f, 0f), "Tile Fill Color", "Set the color of the tile's main color."),
new Param("colorPipes1", new Color(0.41f, 0.54f, 0.34f), "Pipe Outline Color", "Set the color of the pipes' outline."),
new Param("colorPipes2", new Color(0.43f, 0.8f, 0.45f), "Pipe Shading Color", "Set the color of the pipes' shading."),
new Param("colorPipes3", new Color(0.48f, 0.89f, 0.54f), "Pipe Fill Color", "Set the color of the pipes."),
new Param("colorConveyor1", new Color(0.157f, 0.25f, 0.3f), "Conveyor Fill Color", "Set the color of the conveyer belt."),
new Param("colorConveyor2", new Color(0.55f, 0.57f, 0.04f), "Conveyor Trim Color", "Set the conveyor's trim color."),
}
},

24
Assets/Scripts/Games/MeatGrinder/MeatGrinder.cs
View file

@ -33,8 +33,8 @@ namespace HeavenStudio.Games.Loaders
},
parameters = new List<Param>()
{
new Param("bop", true, "Boss Bops?", "Does Boss bop?"),
new Param("bossBop", false, "Boss Bops? (Auto)", "Does Boss Auto bop?"),
new Param("bop", true, "Bop", "Toggle if Boss should bop for the duration of this event."),
new Param("bossBop", false, "Bop (Auto)", "Toggle if Boss should automatically bop until another Bop event is reached."),
},
resizable = true,
priority = 1,
@ -54,7 +54,7 @@ namespace HeavenStudio.Games.Loaders
priority = 2,
parameters = new List<Param>()
{
new Param("bacon", false, "Bacon Ball", "Throw a bacon ball instead of the typical meat"),
new Param("bacon", false, "Bacon Ball", "Toggle if a bacon ball should be thrown instead of the typical dark meat"),
}.Concat(reactionParams).ToList(), // doing this because i want these params to always be the same
},
new GameAction("StartInterval", "Start Interval")
@ -68,7 +68,7 @@ namespace HeavenStudio.Games.Loaders
},
parameters = new List<Param>()
{
new Param("auto", true, "Auto Pass Turn")
new Param("auto", true, "Auto Pass Turn", "Toggle if the turn should be passed automatically at the end of the start interval.")
},
preFunctionLength = 1
},
@ -92,8 +92,8 @@ namespace HeavenStudio.Games.Loaders
MeatGrinder.instance.DoExpressions(e["tackExpression"], e["bossExpression"]);
},
parameters = new List<Param>() {
new Param("tackExpression", MeatGrinder.TackExpressions.Content, "Tack Expression", "The expression Tack will display"),
new Param("bossExpression", MeatGrinder.BossExpressions.None, "Boss Expression", "The expression Boss will display"),
new Param("tackExpression", MeatGrinder.TackExpressions.Content, "Tack", "Set the expression Tack will display."),
new Param("bossExpression", MeatGrinder.BossExpressions.None, "Boss", "Set the expression Boss will display."),
}
},
new GameAction("cartGuy", "Cart Guy")
@ -105,9 +105,9 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
defaultLength = 16,
parameters = new List<Param>() {
new Param("spider", false, "On Phone", "Put a spider in the box?"),
new Param("direction", MeatGrinder.CartGuyDirection.Right, "Direction", "The direction the cart will be carted to."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "What ease will the cart use?"),
new Param("spider", false, "On Phone", "Toggle if Cart Guy should be on his phone."),
new Param("direction", MeatGrinder.CartGuyDirection.Right, "Direction", "Set the direction the cart will be moved to."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action."),
}
},
new GameAction("gears", "Gears")
@ -119,8 +119,8 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
defaultLength = 1,
parameters = new List<Param>() {
new Param("speed", new EntityTypes.Float(0, 10, 1), "Speed", "How fast will the gears go?"),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "What ease will the gears speed up/slow down with?"),
new Param("speed", new EntityTypes.Float(0, 10, 1), "Speed", "Set the speed of the gears."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action"),
}
},
},
@ -298,7 +298,7 @@ namespace HeavenStudio.Games
}
if (CartGuyParentAnim.gameObject.activeSelf) {
Debug.Log(cartPhone ? "PhoneBop" : "Bop");
// Debug.Log(cartPhone ? "PhoneBop" : "Bop");
if (cartPhone) {
CartGuyAnim.DoScaledAnimationAsync("PhoneBop", 0.5f);
} else {

4
Assets/Scripts/Games/Minigame.cs
View file

@ -377,7 +377,7 @@ namespace HeavenStudio.Games
{
if (pair.name == name)
{
Debug.Log($"Playing sound sequence {pair.name} at beat {startBeat}");
// Debug.Log($"Playing sound sequence {pair.name} at beat {startBeat}");
return pair.sequence.Play(startBeat);
}
}
@ -446,7 +446,7 @@ namespace HeavenStudio.Games
{
if (bopRegion.ContainsKey(e.beat))
{
Debug.Log("Two bops on the same beat, ignoring this one");
// Debug.Log("Two bops on the same beat, ignoring this one");
continue;
}
if (isBool)

34
Assets/Scripts/Games/MrUpbeat/MrUpbeat.cs
View file

@ -20,7 +20,7 @@ namespace HeavenStudio.Games.Loaders
},
parameters = new List<Param>()
{
new Param("forceOnbeat", false, "Mr. Downbeat", "Force Mr. Upbeat to step on the beat of the block instead of on the offbeat (only use this if you know what you're doing)"),
new Param("forceOnbeat", false, "Mr. Downbeat", "Toggle if Mr. Upbeat should step on the beat of the block instead of on the offbeat. Only use this if you know what you're doing."),
},
preFunctionLength = 0.5f,
defaultLength = 4f,
@ -35,13 +35,13 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("toggle", false, "Applause", "Plays an applause sound effect."),
new Param("stopBlipping", true, "Stop Blipping", "When the stepping stops, should the blipping stop too?"),
new Param("playDing", true, "Play Ding", "Should this block play a ding?"),
new Param("toggle", false, "Applause", "Toggle if applause should be played."),
new Param("stopBlipping", true, "Stop Blipping", "Toggle if the blipping should stop too."),
new Param("playDing", true, "Play Ding", "Toggle if this block should play a ding?"),
},
preFunctionLength = 0.5f,
},
new GameAction("changeBG", "Change Background Color")
new GameAction("changeBG", "Background Appearance")
{
function = delegate {
var e = eventCaller.currentEntity;
@ -50,9 +50,9 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("start", new Color(0.878f, 0.878f, 0.878f), "Start Color", "The start color for the fade"),
new Param("end", new Color(0.878f, 0.878f, 0.878f), "End Color", "The end color for the fade or the color that will be switched to if -instant- is ticked on"),
new Param("toggle", false, "Instant", "Should the background instantly change color?")
new Param("start", new Color(0.878f, 0.878f, 0.878f), "Start Color", "Set the color at the start of the event."),
new Param("end", new Color(0.878f, 0.878f, 0.878f), "End Color", "Set the color at the start of the event."),
new Param("toggle", false, "Instant", "Toggle if the background should jump to it's end state.")
}
},
new GameAction("upbeatColors", "Upbeat Colors")
@ -64,9 +64,9 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("blipColor", new Color(0, 1f, 0), "Blip Color", "Change blip color"),
new Param("setShadow", false, "Set Shadow Color", "Should Mr. Upbeat's shadow be custom?"),
new Param("shadowColor", new Color(1f, 1f, 1f, 0), "Shadow Color", "If \"Set Shadow Color\" is checked, this will set the shadow's color"),
new Param("blipColor", new Color(0, 1f, 0), "Blip Color", "Set the blip color."),
new Param("setShadow", false, "Custom Shadow Color", "Toggle if Mr. Upbeat's shadow should be custom."),
new Param("shadowColor", new Color(1f, 1f, 1f, 0), "Shadow Color", "Set the shadow color."),
}
},
new GameAction("blipEvents", "Blip Events")
@ -78,10 +78,10 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("letter", "", "Letter To Appear", "Which letter to appear on the blip"),
new Param("shouldGrow", true, "Grow Antenna", "Should Mr. Upbeat's antenna grow every blip?"),
new Param("resetBlip", false, "Reset Antenna", "Should Mr. Upbeat's antenna reset?"),
new Param("shouldBlip", true, "Should Blip", "Should Mr. Upbeat blip every offbeat?"),
new Param("letter", "", "Letter To Appear", "Set the letter to appear on the blip."),
new Param("shouldGrow", true, "Grow Antenna", "Toggle if Mr. Upbeat's antennashould grow on every blip"),
new Param("resetBlip", false, "Reset Antenna", "Toggle if Mr. Upbeat's antenna should reset"),
new Param("shouldBlip", true, "Should Blip", "Toggle if Mr. Upbeat's antenna should blip every offbeat."),
}
},
new GameAction("fourBeatCountInOffbeat", "4 Beat Count-In")
@ -92,7 +92,7 @@ namespace HeavenStudio.Games.Loaders
},
parameters = new List<Param>()
{
new Param("a", true, "A", "A"),
new Param("a", true, "A", "Toggle if numbers should be preceded with \"A-\"."),
},
defaultLength = 4f,
resizable = true,
@ -102,7 +102,7 @@ namespace HeavenStudio.Games.Loaders
inactiveFunction = delegate { MrUpbeat.Count(eventCaller.currentEntity["number"]); },
parameters = new List<Param>()
{
new Param("number", MrUpbeat.Counts.One, "Number", "The sound to play"),
new Param("number", MrUpbeat.Counts.One, "Type", "Set the number to say."),
},
},
new GameAction("forceStepping", "Force Stepping")

42
Assets/Scripts/Games/MunchyMonk/MunchyMonk.cs
View file

@ -21,8 +21,8 @@ namespace HeavenStudio.Games.Loaders
},
parameters = new List<Param>()
{
new Param("bop", true, "Monk Bops?", "Does the monk bop?"),
new Param("autoBop", false, "Monk Bops? (Auto)", "Does the monk auto bop?"),
new Param("bop", true, "Bop", "Toggle if Munchy Monk should bop for the duration of this event."),
new Param("autoBop", false, "Bop (Auto)", "Toggle if Munchy Monk should automatically bop until another Bop event is reached."),
},
resizable = true
},
@ -36,8 +36,8 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("goToSide", MunchyMonk.WhichSide.Right, "Go to Which Side?", "Which side the Monk will move to"),
new Param("ease", EasingFunction.Ease.Linear, "Ease", "Which ease should the movement have?"),
new Param("goToSide", MunchyMonk.WhichSide.Right, "Side", "Choose the side that Munchy Monk will move to."),
new Param("ease", EasingFunction.Ease.Linear, "Ease", "Set the easing of the action."),
},
},
new GameAction("One", "One")
@ -53,7 +53,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 2f,
parameters = new List<Param>()
{
new Param("oneColor", new Color(1, 1, 1, 1), "Color", "Change the color of the dumpling")
new Param("oneColor", new Color(1, 1, 1, 1), "Color", "Set the color of the dumpling.")
},
},
new GameAction("TwoTwo", "Two Two")
@ -61,8 +61,8 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 2f,
parameters = new List<Param>()
{
new Param("twoColor1", new Color(1, 0.51f, 0.45f, 1), "1st Dumpling Color", "Change the color of the first dumpling"),
new Param("twoColor2", new Color(1, 0.51f, 0.45f, 1), "2nd Dumpling Color", "Change the color of the second dumpling"),
new Param("twoColor1", new Color(1, 0.51f, 0.45f, 1), "1st Dumpling Color", "Set the color of the first dumpling."),
new Param("twoColor2", new Color(1, 0.51f, 0.45f, 1), "2nd Dumpling Color", "Set the color of the second dumpling."),
},
preFunctionLength = 0.5f,
preFunction = delegate {
@ -83,9 +83,9 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 4f,
parameters = new List<Param>()
{
new Param("threeColor1", new Color(0.34f, 0.77f, 0.36f, 1), "1st Dumpling Color", "Change the color of the first dumpling"),
new Param("threeColor2", new Color(0.34f, 0.77f, 0.36f, 1), "2nd Dumpling Color", "Change the color of the second dumpling"),
new Param("threeColor3", new Color(0.34f, 0.77f, 0.36f, 1), "3rd Dumpling Color", "Change the color of the third dumpling"),
new Param("threeColor1", new Color(0.34f, 0.77f, 0.36f, 1), "1st Dumpling Color", "Set the color of the first dumpling."),
new Param("threeColor2", new Color(0.34f, 0.77f, 0.36f, 1), "2nd Dumpling Color", "Set the color of the second dumpling."),
new Param("threeColor3", new Color(0.34f, 0.77f, 0.36f, 1), "3rd Dumpling Color", "Set the color of the third dumpling."),
},
},
new GameAction("Modifiers", "Modifiers")
@ -97,11 +97,11 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("inputsTil", new EntityTypes.Integer(0, 50, 10), "How Many 'til Growth?", "How many dumplings are needed to grow the stache?"),
new Param("resetLevel", false, "Remove Hair", "Instantly remove all hair"),
new Param("setLevel", new EntityTypes.Integer(0, 4, 0), "Set Growth Level", "Instantly grow hair"),
new Param("disableBaby", false, "Disable Baby?", "Make baby active or not"),
new Param("shouldBlush", true, "Should Monk Blush?", "Makes the Monk blush or not after eating"),
new Param("inputsTil", new EntityTypes.Integer(0, 50, 10), "Moustache Growth Requirement", "Set how many dumplings Munchy Monk needs to eat for his moustache to grow."),
new Param("resetLevel", false, "Reset Hair Growth", "Toggle if the current amount of moustache growth should be reset."),
new Param("setLevel", new EntityTypes.Integer(0, 4, 0), "Instant Growth", "Set how much hair Munchy Monk should instantly grow at the start of this event."),
new Param("disableBaby", false, "Disable Baby", "Toggle if the baby should appear or not."),
new Param("shouldBlush", true, "Blush", "Toggle if Munchy Monk should blush after eating a dumpling."),
},
},
new GameAction("MonkAnimation", "Monk Animations")
@ -116,8 +116,8 @@ namespace HeavenStudio.Games.Loaders
},
parameters = new List<Param>()
{
new Param("whichAnim", MunchyMonk.WhichMonkAnim.Stare, "Which Animation", "Which animation will the Monk play?"),
new Param("vineBoom", false, "Vine Boom", "Just guess with this one."),
new Param("whichAnim", MunchyMonk.WhichMonkAnim.Stare, "Animation", "Set the animation to play."),
new Param("vineBoom", false, "Vine Boom", "Toggle if a certain sound effect should play."),
}
},
new GameAction("ScrollBackground", "Scroll Background")
@ -130,8 +130,8 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("scrollSpeed", new EntityTypes.Float(0, 20, 5), "Scroll Speed", "What should the scroll speed be?"),
new Param("ease", EasingFunction.Ease.Linear, "Ease", "Which ease should the scroll ramp up have?"),
new Param("scrollSpeed", new EntityTypes.Float(0, 20, 5), "Speed", "Set the speed that the background should scroll."),
new Param("ease", EasingFunction.Ease.Linear, "Ease", "Set the easing of the action."),
}
},
new GameAction("CloudMonkey", "Cloud Monkey")
@ -142,8 +142,8 @@ namespace HeavenStudio.Games.Loaders
},
parameters = new List<Param>()
{
new Param("start", true, "Start Moving", "Start moving the monkey"),
new Param("direction", MunchyMonk.WhichSide.Right, "Direction", "The direction the monkey will move."),
new Param("start", true, "Start", "Toggle if the monkey should start moving."),
new Param("direction", MunchyMonk.WhichSide.Right, "Direction", "Set the direction that the monkey will move."),
},
defaultLength = 8f,
resizable = true,

62
Assets/Scripts/Games/OctopusMachine/OctopusMachine.cs
View file

@ -20,9 +20,9 @@ namespace HeavenStudio.Games.Loaders
OctopusMachine.instance.Bop(e.length, e["whichBop"], e["singleBop"], e["keepBop"]);
},
parameters = new List<Param>() {
new Param("whichBop", OctopusMachine.Bops.Bop, "Which Bop", "Plays a specific bop type"),
new Param("singleBop", true, "Single Bop", "Plays one bop"),
new Param("keepBop", false, "Keep Bopping", "Keeps playing the specified bop type"),
new Param("singleBop", true, "Bop", "Toggle if the octopodes should bop for the duration of this event. Since this event is not stretchable, they will only bop once."),
new Param("keepBop", false, "Bop (Auto)", "Toggle if the octopodes should automatically bop until another Bop event is reached."),
new Param("whichBop", OctopusMachine.Bops.Bop, "Which Bop", "Set the type of bop."),
},
},
new GameAction("startInterval", "Start Interval")
@ -42,11 +42,11 @@ namespace HeavenStudio.Games.Loaders
},
resizable = true,
parameters = new List<Param>() {
new Param("shouldPrep", true, "Prepare?", "Plays a prepare animation before the cue.", new List<Param.CollapseParam>()
new Param("shouldPrep", true, "Prepare", "Toggle if the octopodes should automatically prepare for this cue.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (bool)x, new string[] { "prepBeats" })
}),
new Param("prepBeats", new EntityTypes.Float(0, 4, 1), "Prepare Beats", "How many beats before the cue does the octopus prepare?"),
new Param("prepBeats", new EntityTypes.Float(0, 4, 1), "Prepare Beats", "Set how many beats before the cue the octopodes should prepare."),
},
preFunctionLength = 4f,
preFunction = delegate {
@ -80,14 +80,14 @@ namespace HeavenStudio.Games.Loaders
OctopusMachine.instance.AutoAction(e["forceBop"], e["autoBop"], e["autoText"], e["hitText"], e["missText"]);
},
parameters = new List<Param>() {
new Param("forceBop", true, "Force Bop", "Forces a bop, even if an animation is playing."),
new Param("autoBop", true, "Hit/Miss Bop", "Plays a bop depending on if you hit or missed the cues."),
new Param("autoText", true, "Display Text", "Displays text depending on if you hit or missed the cues.", new List<Param.CollapseParam>()
new Param("forceBop", true, "Force Bop", "Toggle if a bop should be forced to play, even if an animation is already playing."),
new Param("autoBop", true, "Hit/Miss Bop", "Toggle if the octopodes should bop depending on if you hit or missed the cues."),
new Param("autoText", true, "Display Text", "Toggle if text should display depending on if you hit or missed the cues.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (bool)x, new string[] { "hitText", "missText" })
}),
new Param("hitText", "Good!", "Hit Text", "The text to display if you hit the cues."),
new Param("missText", "Wrong! Try again!", "Miss Text", "The text to display if you missed the cues."),
new Param("hitText", "Good!", "Hit Text", "Set the text to display if you hit the cues."),
new Param("missText", "Wrong! Try again!", "Miss Text", "Set the text to display if you missed the cues."),
},
},
new GameAction("forceSqueeze", "Force Squeeze")
@ -106,24 +106,24 @@ namespace HeavenStudio.Games.Loaders
OctopusMachine.instance.BubbleToggle(e["isInstant"], e["setActive"], e["particleStrength"], e["particleSpeed"]);
},
parameters = new List<Param>() {
new Param("isInstant", true, "Instant", "Will the bubbles disappear appear?"),
new Param("setActive", OctopusMachine.Actives.Activate, "Activate or Deactivate", "Will the bubbles disappear or appear?", new List<Param.CollapseParam>()
new Param("isInstant", true, "Instant", "Toggle if the particles should start or stop instantly."),
new Param("setActive", OctopusMachine.Actives.Activate, "State", "Set if the bubbles should appear or disappear.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (int)x == (int)OctopusMachine.Actives.Activate, new string[] { "particleStrength" })
}),
new Param("particleStrength", new EntityTypes.Float(0, 25, 3), "Bubble Intensity", "The amount of bubbles"),
new Param("particleSpeed", new EntityTypes.Float(0, 25, 5), "Bubble Speed", "The speed of the bubbles"),
new Param("particleStrength", new EntityTypes.Float(0, 25, 3), "Intensity", "Set the intensity of the bubbles."),
new Param("particleSpeed", new EntityTypes.Float(0, 25, 5), "Speed", "Set the speed of the bubbles."),
},
},
new GameAction("changeText", "Change Text")
new GameAction("changeText", "Text")
{
function = delegate {
var e = eventCaller.currentEntity;
OctopusMachine.instance.ChangeText(e["text"], e["youText"]);
},
parameters = new List<Param>() {
new Param("text", "Do what the others do.", "Text", "Set the text on the screen"),
new Param("youText", "You", "You Text", "Set the text that orginally says \"You\""),
new Param("text", "Do what the others do.", "Text", "Set the text on the screen."),
new Param("youText", "You", "Player Text", "Set the text that points to the player."),
},
},
new GameAction("changeColor", "Change Color")
@ -133,11 +133,11 @@ namespace HeavenStudio.Games.Loaders
OctopusMachine.instance.BackgroundColor(e.beat, e.length, e["color1"], e["color2"], e["octoColor"], e["squeezedColor"], e["ease"]);
},
parameters = new List<Param>() {
new Param("color1", new Color(1f, 0.87f, 0.24f), "Background Start Color", "Set the beginning background color"),
new Param("color2", new Color(1f, 0.87f, 0.24f), "Background End Color", "Set the end background color"),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease"),
new Param("octoColor", new Color(0.97f, 0.235f, 0.54f), "Octopodes Color", "Set the octopodes' colors"),
new Param("squeezedColor", new Color(1f, 0f, 0f), "Squeezed Color", "Set the octopodes' colors when they're squeezed"),
new Param("color1", new Color(1f, 0.87f, 0.24f), "Start BG Color", "Set the color at the start of the event."),
new Param("color2", new Color(1f, 0.87f, 0.24f), "End BG Color", "Set the color at the end of the event."),
new Param("octoColor", new Color(0.97f, 0.235f, 0.54f), "Octopodes' Color", "Set the octopodes' colors."),
new Param("squeezedColor", new Color(1f, 0f, 0f), "Squeezed Color", "Set the octopodes' colors when they're squeezed."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action."),
},
resizable = true,
},
@ -148,24 +148,24 @@ namespace HeavenStudio.Games.Loaders
OctopusMachine.instance.OctopusModifiers(e.beat, e["oct1x"], e["oct2x"], e["oct3x"], e["oct1y"], e["oct2y"], e["oct3y"], e["oct1"], e["oct2"], e["oct3"]);
},
parameters = new List<Param>() {
new Param("oct1", true, "Show Octopus 1", "Should the first octopus be enabled?", new List<Param.CollapseParam>()
new Param("oct1", true, "Show Octopus 1", "Toggle if the first octopus should be enabled.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (bool)x, new string[] { "oct1x", "oct1y" })
}),
new Param("oct1x", new EntityTypes.Float(-10, 10, -4.64f), "X Octopus 1", "Change Octopus 1's X"),
new Param("oct1y", new EntityTypes.Float(-10, 10, 2.5f), "Y Octopus 1", "Change Octopus 1's Y"),
new Param("oct2", true, "Show Octopus 2", "Should the second octopus be enabled?", new List<Param.CollapseParam>()
new Param("oct1x", new EntityTypes.Float(-10, 10, -4.64f), "X Octopus 1", "Set the position on the X axis of octopus 1."),
new Param("oct1y", new EntityTypes.Float(-10, 10, 2.5f), "Y Octopus 1", "Set the position on the Y axis of octopus 1."),
new Param("oct2", true, "Show Octopus 2", "Toggle if the second octopus should be enabled.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (bool)x, new string[] { "oct2x", "oct2y" })
}),
new Param("oct2x", new EntityTypes.Float(-10, 10, -0.637f), "X Octopus 2", "Change Octopus 2's X"),
new Param("oct2y", new EntityTypes.Float(-10, 10, 0f), "Y Octopus 2", "Change Octopus 2's Y"),
new Param("oct3", true, "Show Octopus 3", "Should the third octopus be enabled?", new List<Param.CollapseParam>()
new Param("oct2x", new EntityTypes.Float(-10, 10, -0.637f), "X Octopus 2", "Set the position on the X axis of octopus 2."),
new Param("oct2y", new EntityTypes.Float(-10, 10, 0f), "Y Octopus 2", "Set the position on the Y axis of octopus 2."),
new Param("oct3", true, "Show Octopus 3", "Toggle if the third octopus should be enabled.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (bool)x, new string[] { "oct3x", "oct3y" })
}),
new Param("oct3x", new EntityTypes.Float(-10, 10, 3.363f), "X Octopus 3", "Change Octopus 3's X"),
new Param("oct3y", new EntityTypes.Float(-10, 10, -2.5f), "Y Octopus 3", "Change Octopus 3's Y"),
new Param("oct3x", new EntityTypes.Float(-10, 10, 3.363f), "X Octopus 3", "Set the position on the X axis of octopus 3."),
new Param("oct3y", new EntityTypes.Float(-10, 10, -2.5f), "Y Octopus 3", "Set the position on the Y axis of octopus 3."),
},
defaultLength = 0.5f,
},

16
Assets/Scripts/Games/PajamaParty/PajamaParty.cs
View file

@ -23,8 +23,8 @@ namespace HeavenStudio.Games.Loaders
function = delegate { var e = eventCaller.currentEntity; PajamaParty.instance.Bop(e.beat, e.length, e["bop"], e["autoBop"]); },
parameters = new List<Param>()
{
new Param("bop", true, "Keep Bopping", "Should Mako and the monkeys bop for the duration of the block?"),
new Param("autoBop", false, "Keep Bopping (Auto)", "Should Mako and the monkeys bop indefinitely?"),
new Param("bop", true, "Bop", "Toggle if Mako and the monkeys should bop for the duration of this event."),
new Param("autoBop", false, "Bop (Auto)", "Toggle if Mako and the monkeys should automatically bop until another Bop event is reached."),
},
resizable = true,
},
@ -48,8 +48,8 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 8f,
parameters = new List<Param>()
{
new Param("type", PajamaParty.SleepType.Normal, "Sleep Type", "Type of sleep action to use"),
new Param("toggle", false, "Alt. Animation", "Use an alternate animation for Mako")
new Param("type", PajamaParty.SleepType.Normal, "Type", "Set the type of sleep action to use."),
new Param("toggle", false, "Alternate Animation", "Toggle if Mako should sleep using an alternate \"stretching\" animation.")
},
inactiveFunction = delegate { var e = eventCaller.currentEntity; PajamaParty.WarnSleepSequence(e.beat, e["toggle"], e["type"]); }
},
@ -60,7 +60,7 @@ namespace HeavenStudio.Games.Loaders
inactiveFunction = delegate { var e = eventCaller.currentEntity; PajamaParty.WarnThrowSequence(e.beat, e["high"]); },
parameters = new List<Param>()
{
new Param("high", false, "Change Costumes", "Change character costumes"),
new Param("high", false, "Change Costumes", "Toggle if the character costumes should change on a successful throw."),
},
},
new GameAction("open background", "Open / Close Background")
@ -70,7 +70,7 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("instant", false, "Instant", "Instantly open / close the background"),
new Param("instant", false, "Instant", "Toggle if the background should be instantly opened or closed."),
},
},
new GameAction("dream boats", "Background Boats")
@ -84,7 +84,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("toggle", true, "Change Costumes", "Enable / disable costumes"),
new Param("toggle", true, "Change Costumes", "Toggle if the character costumes should change."),
},
priority = 5,
},
@ -96,7 +96,7 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("type", PajamaParty.SleepType.Normal, "Sleep Type", "Type of sleep action to use"),
new Param("type", PajamaParty.SleepType.Normal, "Type", "Set the type of sleep action to use."),
},
priority = 5,
},

40
Assets/Scripts/Games/QuizShow/QuizShow.cs
View file

@ -22,14 +22,14 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("auto", true, "Auto Pass Turn", "", new List<Param.CollapseParam>()
new Param("auto", true, "Auto Pass Turn", "Toggle if the turn should be passed automatically at the end of the start interval.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (bool)x, new string[] { "sound", "con", "visual", "audio" })
}),
new Param("sound", true, "Play Time-Up Sound?", "Should the Time-Up sound play at the end of the interval?"),
new Param("con", false, "Consecutive", "Disables everything that happens at the end of the interval if ticked on."),
new Param("visual", true, "Stopwatch (Visual)", "Should the stopwatch visually appear?"),
new Param("audio", QuizShow.ClockAudio.Both, "Stopwatch (Audio)", "Should the sounds of the stopwatch play?")
new Param("sound", true, "Time-Up Sound", "Toggle if the time-up sound should play at the end of the interval."),
new Param("con", false, "Consecutive", "Toggle if everything that happens at the end of the interval should be disabled. This should only be used when you're having two intervals back-to-back."),
new Param("visual", true, "Stopwatch (Visual)", "Toggle if the stopwatch should visually appear."),
new Param("audio", QuizShow.ClockAudio.Both, "Stopwatch (Audio)", "Toggle if the sounds of the stopwatch should play.")
}
},
new GameAction("prepare", "Prepare Host Hands")
@ -48,10 +48,10 @@ namespace HeavenStudio.Games.Loaders
{
parameters = new List<Param>()
{
new Param("min", new EntityTypes.Integer(0, 666, 0), "Minimum", "The minimum number of presses this block will do."),
new Param("max", new EntityTypes.Integer(0, 666, 1), "Maximum", "The maximum number of presses this block will do."),
new Param("random", QuizShow.WhichButtonRandom.Random, "Which Buttons", "Which buttons will be pressed randomly?"),
new Param("con", true, "Consecutive Presses", "Will the presses be consecutive? As in if the first press doesn't trigger, the ones proceeding will not either.")
new Param("min", new EntityTypes.Integer(0, 666, 0), "Minimum", "Set the minimum number of presses this event will do."),
new Param("max", new EntityTypes.Integer(0, 666, 1), "Maximum", "Set the maximum number of presses this event will do."),
new Param("random", QuizShow.WhichButtonRandom.Random, "Buttons", "Set the buttons to be pressed randomly."),
new Param("con", true, "Consecutive Presses", "Toggle if the presses will be consecutive? This means that if the first press doesn't trigger, the ones proceeding will not either.")
},
resizable = true
},
@ -60,10 +60,10 @@ namespace HeavenStudio.Games.Loaders
preFunction = delegate {var e = eventCaller.currentEntity; QuizShow.PrePassTurn(e.beat, e["sound"], e["con"], e["visual"], e["audio"]); },
parameters = new List<Param>()
{
new Param("sound", true, "Play Time-Up Sound?", "Should the Time-Up sound play at the end of the interval?"),
new Param("con", false, "Consecutive", "Disables everything that happens at the end of the interval if ticked on."),
new Param("visual", true, "Stopwatch (Visual)", "Should the stopwatch visually appear?"),
new Param("audio", QuizShow.ClockAudio.Both, "Stopwatch (Audio)", "Should the sounds of the stopwatch play?")
new Param("sound", true, "Time-Up Sound", "Toggle if the time-up sound should play at the end of the interval."),
new Param("con", false, "Consecutive", "Toggle if everything that happens at the end of the interval should be disabled. This should only be used when you're having two intervals back-to-back."),
new Param("visual", true, "Stopwatch (Visual)", "Toggle if the stopwatch should visually appear."),
new Param("audio", QuizShow.ClockAudio.Both, "Stopwatch (Audio)", "Toggle if the sounds of the stopwatch should play.")
},
resizable = true
},
@ -78,18 +78,18 @@ namespace HeavenStudio.Games.Loaders
function = delegate { var e = eventCaller.currentEntity; QuizShow.instance.AnswerReaction(e["audience"], e["jingle"], e["reveal"]); },
parameters = new List<Param>()
{
new Param("audience", true, "Audience", "Should the audience make a sound?"),
new Param("jingle", false, "Jingle", "Should the quiz show jingle play?"),
new Param("reveal", false, "Reveal Answer (Instant)", "Should the answer be revealed when this block starts?")
new Param("audience", true, "Audience Reaction", "Toggle if there should be an audience reaction.."),
new Param("jingle", false, "Jingle", "Toggle if the quiz show jingle should."),
new Param("reveal", false, "Instant", "Toggle if the answer should be revealed insantly when this event starts.")
}
},
new GameAction("changeStage", "Change Expression Stage")
new GameAction("changeStage", "Change Expression")
{
function = delegate {QuizShow.instance.ChangeStage(eventCaller.currentEntity["value"]);},
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("value", QuizShow.HeadStage.Stage1, "Stage", "What's the current stage of the expressions?")
new Param("value", QuizShow.HeadStage.Stage1, "Stage", "Set the current stage of the expressions.")
}
},
new GameAction("countMod", "Count Modifier")
@ -98,7 +98,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("value", true, "Should Reset Count?", "Will the contestant's counter reset to 0 each time it hits 100 instead of exploding?")
new Param("value", true, "Auto Reset Count", "Toggle if the contestant's counter will reset to 0 each time it hits 100 instead of exploding.")
}
},
new GameAction("forceExplode", "Force Explode")
@ -107,7 +107,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("value", QuizShow.ShouldExplode.Contestant, "What To Explode", "What will explode?")
new Param("value", QuizShow.ShouldExplode.Contestant, "Target", "Set the object to explode.")
}
}
},

16
Assets/Scripts/Games/RhythmRally/RhythmRally.cs
View file

@ -23,8 +23,8 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("bop", true, "Bop", "Will the paddlers bop?"),
new Param("bopAuto", false, "Bop (Auto)", "Will the paddlers auto bop?")
new Param("bop", true, "Bop", "Toggle if the paddlers should bop for the duration of this event."),
new Param("bopAuto", false, "Bop (Auto)", "Toggle if the paddlers should automatically bop until another Bop event is reached.")
}
},
new GameAction("whistle", "Whistle")
@ -56,7 +56,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 6f,
parameters = new List<Param>()
{
new Param("muteAudio", false, "Mute Cowbell", "Whether the cowbell sound should play or not.")
new Param("muteAudio", false, "Mute Cowbell", "Toggle if the cowbell \"tonk-tink-tonk\" sound should be muted.")
}
},
new GameAction("superfast rally", "Superfast Rally")
@ -65,7 +65,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 12f,
parameters = new List<Param>()
{
new Param("muteAudio", false, "Mute Cowbell", "Whether the cowbell sound should play or not.")
new Param("muteAudio", false, "Mute Cowbell", "Toggle if the cowbell \"tonk-tink-tonk\" sound should be muted.")
}
},
new GameAction("tonktinktonk", "Tonk-Tink-Tonk (Stretchable)")
@ -95,10 +95,10 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 4,
resizable = true,
parameters = new List<Param>() {
new Param("valA", new EntityTypes.Integer(-360, 360, 0), "Angle", "The rotation of the camera around the center of the table"),
new Param("valB", new EntityTypes.Float(0.5f, 4f, 1), "Zoom", "The camera's level of zoom (Lower value = Zoomed in)"),
new Param("type", Util.EasingFunction.Ease.Linear, "Ease", "The easing function to use"),
new Param("additive", true, "Additive Rotation", "Add to current angle instead of setting target angle")
new Param("valA", new EntityTypes.Integer(-360, 360, 0), "Rotation", "Set the rotation of the camera around the center of the table."),
new Param("valB", new EntityTypes.Float(0.5f, 4f, 1), "Zoom", "Set the camera's level of zoom."),
new Param("type", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action."),
new Param("additive", true, "Additive Rotation", "Toggle if the above rotation should be added to the current angle instead of setting the target angle to travel to.")
}
},
// todo: background recolouring

20
Assets/Scripts/Games/RhythmSomen/RhythmSomen.cs
View file

@ -12,6 +12,16 @@ namespace HeavenStudio.Games.Loaders
{
return new Minigame("rhythmSomen", "Rhythm Sōmen", "7ab96e", false, false, new List<GameAction>()
{
new GameAction("bop", "Bop")
{
function = delegate { var e = eventCaller.currentEntity; RhythmSomen.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("crane (far)", "Far Crane")
{
function = delegate { RhythmSomen.instance.DoFarCrane(eventCaller.currentEntity.beat); },
@ -34,16 +44,6 @@ namespace HeavenStudio.Games.Loaders
new GameAction("slurp", "Slurp")
{
function = delegate { RhythmSomen.instance.Slurp(eventCaller.currentEntity.beat); }
},
new GameAction("bop", "Bop")
{
function = delegate { var e = eventCaller.currentEntity; RhythmSomen.instance.ToggleBop(e.beat, e.length, e["toggle2"], e["toggle"]); },
resizable = true,
parameters = new List<Param>()
{
new Param("toggle2", true, "Bop", "Should the somen man bop?"),
new Param("toggle", false, "Bop (Auto)", "Should the somen man bop automatically?")
}
}
},
new List<string>() { "pco", "normal" },

25
Assets/Scripts/Games/RhythmTweezers/RhythmTweezers.cs
View file

@ -22,7 +22,7 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("auto", true, "Auto Pass Turn", "Will the turn automatically be passed at the end of this event?")
new Param("auto", true, "Auto Pass Turn", "Toggle if the turn should be passed automatically at the end of the start interval.")
}
},
new GameAction("short hair", "Short Hair")
@ -48,10 +48,10 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("type", RhythmTweezers.VegetableType.Onion, "Type", "The vegetable to switch to"),
new Param("colorA", RhythmTweezers.defaultOnionColor, "Onion Color", "The color of the onion"),
new Param("colorB", RhythmTweezers.defaultPotatoColor, "Potato Color", "The color of the potato"),
new Param("instant", false, "Instant", "Instantly change vegetable?")
new Param("type", RhythmTweezers.VegetableType.Onion, "Type", "Set the vegetable to switch to."),
new Param("colorA", RhythmTweezers.defaultOnionColor, "Onion Color", "Set the color of the onion."),
new Param("colorB", RhythmTweezers.defaultPotatoColor, "Potato Color", "Set the color of the potato."),
new Param("instant", false, "Instant", "Toggle if the vegetable should skip the moving animation and instantly swap.")
},
priority = 3
},
@ -62,10 +62,10 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("type", RhythmTweezers.NoPeekSignType.Full, "Sign Type", "Which sign will be used?")
new Param("type", RhythmTweezers.NoPeekSignType.Full, "Side", "Set the side for the sign to appear on.")
}
},
new GameAction("fade background color", "Background Color")
new GameAction("fade background color", "Background Appearance")
{
function = delegate
{
@ -75,9 +75,9 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("colorA", Color.white, "Start Color", "The starting color in the fade"),
new Param("colorB", RhythmTweezers.defaultBgColor, "End Color", "The ending color in the fade"),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease")
new Param("colorA", Color.white, "Start Color", "Set the color at the start of the event."),
new Param("colorB", RhythmTweezers.defaultBgColor, "End Color", "Set the color at the end of the event."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.")
}
},
new GameAction("altSmile", "Use Alt Smile")
@ -274,6 +274,11 @@ namespace HeavenStudio.Games
public override void OnPlay(double beat)
{
crHandlerInstance = null;
foreach (var evt in scheduledInputs)
{
evt.Disable();
}
queuedIntervals.Clear();
PersistBlocks(beat);
}

42
Assets/Scripts/Games/Ringside/Ringside.cs
View file

@ -15,13 +15,23 @@ namespace HeavenStudio.Games.Loaders
{
return new Minigame("ringside", "Ringside", "6bdfe7", false, false, new List<GameAction>()
{
new GameAction("toggleBop", "Bop")
{
function = delegate {var e = eventCaller.currentEntity; Ringside.instance.ToggleBop(e.beat, e.length, e["bop2"], e["bop"]); },
parameters = new List<Param>()
{
new Param("bop2", true, "Bop", "Toggle if the wrestler should bop for the duration of this event."),
new Param("bop", false, "Bop (Auto)", "Toggle if the wrestler should automatically bop until another Bop event is reached."),
},
resizable = true,
},
new GameAction("question", "Question")
{
function = delegate {var e = eventCaller.currentEntity; Ringside.instance.Question(e.beat, e["alt"], e["variant"]); },
parameters = new List<Param>()
{
new Param("alt", false, "Alt", "Whether the alt voice line should be used or not."),
new Param("variant", Ringside.QuestionVariant.Random, "Variant", "Which variant of the cue do you wish to play.")
new Param("alt", false, "Alternate Voice Line", "Toggle if the reporter should use an alternate voice line."),
new Param("variant", Ringside.QuestionVariant.Random, "Variant", "Choose the variant of the cue.")
},
defaultLength = 4f
},
@ -30,7 +40,7 @@ namespace HeavenStudio.Games.Loaders
function = delegate {var e = eventCaller.currentEntity; Ringside.instance.BigGuy(e.beat, e["variant"]); },
parameters = new List<Param>()
{
new Param("variant", Ringside.QuestionVariant.Random, "Variant", "Which variant of the cue do you wish to play.")
new Param("variant", Ringside.QuestionVariant.Random, "Variant", "Choose the variant of the cue.")
},
defaultLength = 4f
},
@ -39,30 +49,20 @@ namespace HeavenStudio.Games.Loaders
preFunction = delegate {var e = eventCaller.currentEntity; Ringside.PoseForTheFans(e.beat, e["and"], e["variant"], e["keepZoomedOut"], e["newspaperBeats"]); },
parameters = new List<Param>()
{
new Param("and", false, "And", "Whether the And voice line should be said or not."),
new Param("variant", Ringside.PoseForTheFansVariant.Random, "Variant", "Which variant of the cue do you wish to play."),
new Param("keepZoomedOut", false, "Keep Zoomed Out", "Whether the camera should keep being zoomed out after the event has completed."),
new Param("newspaperBeats", new EntityTypes.Float(0, 80, 0), "Newspaper Beats", "How many beats should the newspaper stay for?"),
new Param("ease", Util.EasingFunction.Ease.EaseOutQuad, "Camera Ease", "What ease should the camera use?"),
new Param("and", false, "And", "Toggle if the camera crew should say \"And\" before saying the rest of the cue."),
new Param("variant", Ringside.PoseForTheFansVariant.Random, "Variant", "Choose the variant of the cue."),
new Param("keepZoomedOut", false, "Stay Zoomed Out", "Toggle if the camera should stay zoomed out after the event."),
new Param("newspaperBeats", new EntityTypes.Float(0, 80, 0), "Newspaper Beats", "Set how many beats the newspaper should be visible for."),
new Param("ease", Util.EasingFunction.Ease.EaseOutQuad, "Ease", "Set the easing of the action."),
},
defaultLength = 4f
},
new GameAction("toggleBop", "Bop")
{
function = delegate {var e = eventCaller.currentEntity; Ringside.instance.ToggleBop(e.beat, e.length, e["bop2"], e["bop"]); },
parameters = new List<Param>()
{
new Param("bop2", true, "Bop?", "Whether the wrestler should bop or not."),
new Param("bop", false, "Bop? (Auto)", "Whether the wrestler should bop automatically or not."),
},
resizable = true,
},
new GameAction("toggleSweat", "Toggle Sweat")
{
function = delegate {var e = eventCaller.currentEntity; Ringside.instance.ToggleSweat(e["sweat"]); },
parameters = new List<Param>()
{
new Param("sweat", false, "Sweat?", "Whether the wrestler should sweat or not."),
new Param("sweat", false, "Sweat", "Toggle if the wrestler should sweat."),
},
defaultLength = 0.5f
},
@ -72,8 +72,8 @@ namespace HeavenStudio.Games.Loaders
preFunction = delegate {if (Ringside.instance == null) return; var e = eventCaller.currentEntity; Ringside.instance.PreQuestion(e.beat, e["variant"], e.length); },
parameters = new List<Param>()
{
new Param("alt", false, "Alt", "Whether the alt voice line should be used or not."),
new Param("variant", Ringside.QuestionVariant.Random, "Variant", "Which variant of the cue do you wish to play.")
new Param("alt", false, "Alternate Voice Line", "Toggle if the reporter should use an alternate voice line."),
new Param("variant", Ringside.QuestionVariant.Random, "Variant", "Choose the variant of the cue.")
},
defaultLength = 4f,
resizable = true

202
Assets/Scripts/Games/Rockers/Rockers.cs
View file

@ -23,9 +23,9 @@ namespace HeavenStudio.Games.Loaders
preFunction = delegate { var e = eventCaller.currentEntity; Rockers.PreInterval(e.beat, e.length, e["auto"], e["moveCamera"], e["movePass"]); },
parameters = new List<Param>()
{
new Param("moveCamera", true, "Move Camera", "Should the camera move?"),
new Param("movePass", true, "Move Camera (Pass Turn)", "Should the camera move at the auto pass turn?"),
new Param("auto", true, "Auto Pass Turn")
new Param("moveCamera", true, "Move Camera", "Toggle if the camera should move to JJ Rocker."),
new Param("movePass", true, "Move Camera (Pass Turn)", "Toggle if the camera should move to Soshi if Auto Pass Turn is enabled."),
new Param("auto", true, "Auto Pass Turn", "Toggle if the turn should be passed automatically at the end of the start interval.")
},
},
new GameAction("riff", "Riff")
@ -34,25 +34,25 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("respond", true, "Respond", "Will this guitar riff have to be responded to?"),
new Param("1JJ", new EntityTypes.Integer(-1, 24, 0), "E2 String (JJ)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("2JJ", new EntityTypes.Integer(-1, 24, 0), "A2 String (JJ)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("3JJ", new EntityTypes.Integer(-1, 24, 0), "D3 String (JJ)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("4JJ", new EntityTypes.Integer(-1, 24, 0), "G3 String (JJ)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("5JJ", new EntityTypes.Integer(-1, 24, 0), "B3 String (JJ)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("6JJ", new EntityTypes.Integer(-1, 24, 0), "E4 String (JJ)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("sampleJJ", Rockers.PremadeSamples.None, "Premade Sample (JJ)", "Use a premade sample?"),
new Param("pitchSampleJJ", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones (JJ)", "Pitch up the sample by X amount of semitones?"),
new Param("gcJJ", false, "Glee Club Guitar (JJ)", "Will JJ use the same guitar as in the glee club lessons?"),
new Param("1S", new EntityTypes.Integer(-1, 24, 0), "E2 String (Soshi)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("2S", new EntityTypes.Integer(-1, 24, 0), "A2 String (Soshi)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("3S", new EntityTypes.Integer(-1, 24, 0), "D3 String (Soshi)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("4S", new EntityTypes.Integer(-1, 24, 0), "G3 String (Soshi)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("5S", new EntityTypes.Integer(-1, 24, 0), "B3 String (Soshi)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("6S", new EntityTypes.Integer(-1, 24, 0), "E4 String (Soshi)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("sampleS", Rockers.PremadeSamples.None, "Premade Sample (Soshi)", "Use a premade sample?"),
new Param("pitchSampleS", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones (Soshi)", "Pitch up the sample by X amount of semitones?"),
new Param("gcS", false, "Glee Club Guitar (Soshi)", "Will Soshi use the same guitar as in the glee club lessons?")
new Param("respond", true, "Respond", "Toggle if this guitar riff will have to be responded to by Soshi (the player)."),
new Param("1JJ", new EntityTypes.Integer(-1, 24, 0), "E2 String (JJ)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("2JJ", new EntityTypes.Integer(-1, 24, 0), "A2 String (JJ)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("3JJ", new EntityTypes.Integer(-1, 24, 0), "D3 String (JJ)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("4JJ", new EntityTypes.Integer(-1, 24, 0), "G3 String (JJ)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("5JJ", new EntityTypes.Integer(-1, 24, 0), "B3 String (JJ)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("6JJ", new EntityTypes.Integer(-1, 24, 0), "E4 String (JJ)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("sampleJJ", Rockers.PremadeSamples.None, "Premade Sample (JJ)", "Set if this riff should use a premade sample."),
new Param("pitchSampleJJ", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones (JJ)", "Set how many semitones the premade sample should be pitched up."),
new Param("gcJJ", false, "Glee Club Guitar (JJ)", "Toggle if JJ should use the same guitar as in the Glee Club guitar lessons in DS."),
new Param("1S", new EntityTypes.Integer(-1, 24, 0), "E2 String (Soshi)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("2S", new EntityTypes.Integer(-1, 24, 0), "A2 String (Soshi)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("3S", new EntityTypes.Integer(-1, 24, 0), "D3 String (Soshi)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("4S", new EntityTypes.Integer(-1, 24, 0), "G3 String (Soshi)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("5S", new EntityTypes.Integer(-1, 24, 0), "B3 String (Soshi)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("6S", new EntityTypes.Integer(-1, 24, 0), "E4 String (Soshi)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("sampleS", Rockers.PremadeSamples.None, "Premade Sample (Soshi)", "Set if this riff should use a premade sample."),
new Param("pitchSampleS", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones (Soshi)", "Set how many semitones the premade sample should be pitched up."),
new Param("gcS", false, "Glee Club Guitar (Soshi)", "Toggle if Soshi should use the same guitar as in the Glee Club guitar lessons in DS.")
},
},
new GameAction("bend", "Bend")
@ -61,9 +61,9 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("respond", true, "Respond", "Will this guitar bend have to be responded to?"),
new Param("1JJ", new EntityTypes.Integer(-24, 24, 1), "Pitch Bend (JJ)", "How many semitones up is the current riff gonna be pitchbended?"),
new Param("1S", new EntityTypes.Integer(-24, 24, 1), "Pitch Bend (Soshi)", "How many semitones up is the current riff gonna be pitchbended?"),
new Param("respond", true, "Respond", "Toggle if this guitar bend will have to be responded to by Soshi (the player)."),
new Param("1JJ", new EntityTypes.Integer(-24, 24, 1), "Pitch Bend (JJ)", "Set how many semitones up the current riff will be pitchbent."),
new Param("1S", new EntityTypes.Integer(-24, 24, 1), "Pitch Bend (Soshi)", "Set how many semitones up the current riff will be pitchbent."),
},
},
new GameAction("prepare", "Prepare")
@ -72,7 +72,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("who", Rockers.WhoMutes.JJ, "Who?", "Who will prepare? (Soshi is only affected by this event in auto-play.)")
new Param("who", Rockers.WhoMutes.JJ, "Target", "Set who will prepare. Soshi is only affected by this event in auto-play.")
}
},
new GameAction("unPrepare", "Unprepare")
@ -81,7 +81,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("who", Rockers.WhoMutes.JJ, "Who?", "Who will unprepare? (Soshi is only affected by this event in auto-play.)")
new Param("who", Rockers.WhoMutes.JJ, "Target", "Set who will unprepare. Soshi is only affected by this event in auto-play.")
}
},
new GameAction("passTurn", "Pass Turn")
@ -89,7 +89,7 @@ namespace HeavenStudio.Games.Loaders
preFunction = delegate { var e = eventCaller.currentEntity; Rockers.PrePassTurn(e.beat, e["moveCamera"]); },
parameters = new List<Param>
{
new Param("moveCamera", true, "Move Camera", "Should the camera move?")
new Param("moveCamera", true, "Move Camera", "Toggle if the camera should move to Soshi.")
},
preFunctionLength = 1
},
@ -124,23 +124,23 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 11,
parameters = new List<Param>()
{
new Param("moveCamera", true, "Move Camera", "Should the camera move?"),
new Param("JJ1", Rockers.PremadeSamples.ChordG5, "Premade Sample 1 (JJ)", "What sample to use for the 1st riff?"),
new Param("pJJ1", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones 1 (JJ)", "Pitch up the sample by X amount of semitones?"),
new Param("JJ2", Rockers.PremadeSamples.ChordG5, "Premade Sample 2 (JJ)", "What sample to use for the 2nd riff?"),
new Param("pJJ2", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones 2 (JJ)", "Pitch up the sample by X amount of semitones?"),
new Param("JJ3", Rockers.PremadeSamples.ChordG5, "Premade Sample 3 (JJ)", "What sample to use for the 3rd riff?"),
new Param("pJJ3", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones 3 (JJ)", "Pitch up the sample by X amount of semitones?"),
new Param("JJ4", Rockers.PremadeSamples.ChordA, "Premade Sample 4 (JJ)", "What sample to use for the final riff?"),
new Param("pJJ4", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones 4 (JJ)", "Pitch up the sample by X amount of semitones?"),
new Param("S1", Rockers.PremadeSamples.ChordG, "Premade Sample 1 (Soshi)", "What sample to use for the 1st riff?"),
new Param("pS1", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones 1 (Soshi)", "Pitch up the sample by X amount of semitones?"),
new Param("S2", Rockers.PremadeSamples.ChordG, "Premade Sample 2 (Soshi)", "What sample to use for the 2nd riff?"),
new Param("pS2", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones 2 (Soshi)", "Pitch up the sample by X amount of semitones?"),
new Param("S3", Rockers.PremadeSamples.ChordG, "Premade Sample 3 (Soshi)", "What sample to use for the 3rd riff?"),
new Param("pS3", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones 3 (Soshi)", "Pitch up the sample by X amount of semitones?"),
new Param("S4", Rockers.PremadeSamples.ChordA, "Premade Sample 4 (Soshi)", "What sample to use for the final riff?"),
new Param("pS4", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones 4 (Soshi)", "Pitch up the sample by X amount of semitones?"),
new Param("moveCamera", true, "Move Camera", "Toggle if the camera should move to the middle."),
new Param("JJ1", Rockers.PremadeSamples.ChordG5, "Premade Sample 1 (JJ)", "Set the sample to use for the 1st riff."),
new Param("pJJ1", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones 1 (JJ)", "Set how many semitones the premade sample should be pitched up."),
new Param("JJ2", Rockers.PremadeSamples.ChordG5, "Premade Sample 2 (JJ)", "Set the sample to use for the 2nd riff."),
new Param("pJJ2", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones 2 (JJ)", "Set how many semitones the premade sample should be pitched up."),
new Param("JJ3", Rockers.PremadeSamples.ChordG5, "Premade Sample 3 (JJ)", "Set the sample to use for the 3rd riff."),
new Param("pJJ3", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones 3 (JJ)", "Set how many semitones the premade sample should be pitched up."),
new Param("JJ4", Rockers.PremadeSamples.ChordA, "Premade Sample 4 (JJ)", "Set the sample to use for the final riff."),
new Param("pJJ4", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones 4 (JJ)", "Set how many semitones the premade sample should be pitched up."),
new Param("S1", Rockers.PremadeSamples.ChordG, "Premade Sample 1 (Soshi)", "Set the sample to use for the 1st riff."),
new Param("pS1", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones 1 (Soshi)", "Set how many semitones the premade sample should be pitched up."),
new Param("S2", Rockers.PremadeSamples.ChordG, "Premade Sample 2 (Soshi)", "Set the sample to use for the 2nd riff."),
new Param("pS2", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones 2 (Soshi)", "Set how many semitones the premade sample should be pitched up."),
new Param("S3", Rockers.PremadeSamples.ChordG, "Premade Sample 3 (Soshi)", "Set the sample to use for the 3rd riff."),
new Param("pS3", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones 3 (Soshi)", "Set how many semitones the premade sample should be pitched up."),
new Param("S4", Rockers.PremadeSamples.ChordA, "Premade Sample 4 (Soshi)", "Set the sample to use for the final riff."),
new Param("pS4", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones 4 (Soshi)", "Set how many semitones the premade sample should be pitched up."),
}
},
new GameAction("lastOne", "Last One!")
@ -170,26 +170,26 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 7,
parameters = new List<Param>()
{
new Param("moveCamera", true, "Move Camera", "Should the camera move?"),
new Param("JJ1", Rockers.PremadeSamples.ChordAsus4, "Premade Sample 1 (JJ)", "What sample to use for the 1st riff?"),
new Param("pJJ1", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones 1 (JJ)", "Pitch up the sample by X amount of semitones?"),
new Param("JJ2", Rockers.PremadeSamples.ChordAsus4, "Premade Sample 2 (JJ)", "What sample to use for the 2nd riff?"),
new Param("pJJ2", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones 2 (JJ)", "Pitch up the sample by X amount of semitones?"),
new Param("JJ3", Rockers.PremadeSamples.ChordAsus4, "Premade Sample 3 (JJ)", "What sample to use for the final riff?"),
new Param("pJJ3", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones 3 (JJ)", "Pitch up the sample by X amount of semitones?"),
new Param("S1", Rockers.PremadeSamples.ChordDmaj9, "Premade Sample 1 (Soshi)", "What sample to use for the 1st riff?"),
new Param("pS1", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones 1 (Soshi)", "Pitch up the sample by X amount of semitones?"),
new Param("S2", Rockers.PremadeSamples.ChordDmaj9, "Premade Sample 2 (Soshi)", "What sample to use for the 2nd riff?"),
new Param("pS2", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones 2 (Soshi)", "Pitch up the sample by X amount of semitones?"),
new Param("S3", Rockers.PremadeSamples.ChordDmaj9, "Premade Sample 3 (Soshi)", "What sample to use for the final riff?"),
new Param("pS3", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones 3 (Soshi)", "Pitch up the sample by X amount of semitones?"),
new Param("moveCamera", true, "Move Camera", "Toggle if the camera should move to the middle."),
new Param("JJ1", Rockers.PremadeSamples.ChordAsus4, "Premade Sample 1 (JJ)", "Set the sample to use for the 1st riff."),
new Param("pJJ1", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones 1 (JJ)", "Set how many semitones the premade sample should be pitched up."),
new Param("JJ2", Rockers.PremadeSamples.ChordAsus4, "Premade Sample 2 (JJ)", "Set the sample to use for the 2nd riff."),
new Param("pJJ2", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones 2 (JJ)", "Set how many semitones the premade sample should be pitched up."),
new Param("JJ3", Rockers.PremadeSamples.ChordAsus4, "Premade Sample 3 (JJ)", "Set the sample to use for the final riff."),
new Param("pJJ3", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones 3 (JJ)", "Set how many semitones the premade sample should be pitched up."),
new Param("S1", Rockers.PremadeSamples.ChordDmaj9, "Premade Sample 1 (Soshi)", "Set the sample to use for the 1st riff."),
new Param("pS1", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones 1 (Soshi)", "Set how many semitones the premade sample should be pitched up."),
new Param("S2", Rockers.PremadeSamples.ChordDmaj9, "Premade Sample 2 (Soshi)", "Set the sample to use for the 2nd riff."),
new Param("pS2", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones 2 (Soshi)", "Set how many semitones the premade sample should be pitched up."),
new Param("S3", Rockers.PremadeSamples.ChordDmaj9, "Premade Sample 3 (Soshi)", "Set the sample to use for the final riff."),
new Param("pS3", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones 3 (Soshi)", "Set how many semitones the premade sample should be pitched up."),
}
},
new GameAction("count", "Count In")
new GameAction("count", "Count")
{
parameters = new List<Param>()
{
new Param("count", Rockers.CountIn.One, "Count", "Which voiceline?")
new Param("count", Rockers.CountIn.One, "Type", "Set the number to be said.")
},
preFunction = delegate
{
@ -215,7 +215,7 @@ namespace HeavenStudio.Games.Loaders
{
parameters = new List<Param>()
{
new Param("cmon", true, "C'mon!", "Use the C'mon voiceline? If unchecked it uses the Last One voiceline."),
new Param("cmon", true, "C'mon!", "Toggle if the \"C'mon!\" voiceline should be used. If unchecked, it uses the \"Last One!\" voiceline."),
},
preFunction = delegate
{
@ -229,10 +229,10 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 3f,
parameters = new List<Param>()
{
new Param("cmon", Rockers.VoiceLineSelection.Cmon, "Voiceline", "Which voiceline should be used?"),
new Param("muteBeat", new EntityTypes.Integer(0, 30, 2), "Mute Beat", "How many beats from the start of this event will they prepare mute?"),
new Param("middleBeat", new EntityTypes.Integer(0, 30, 2), "Go-to-middle Beat", "How many beats from the start of this event will they go to the middle?"),
new Param("moveCamera", true, "Move Camera", "Should the camera move?")
new Param("cmon", Rockers.VoiceLineSelection.Cmon, "Voiceline", "Set the voiceline to be used."),
new Param("muteBeat", new EntityTypes.Integer(0, 30, 2), "Mute Beat", "Set how many beats from the start of this event the rockers will prepare prepare."),
new Param("middleBeat", new EntityTypes.Integer(0, 30, 2), "Go-to-middle Beat", "Set how many beats from the start of this event the rockers will go to the middle."),
new Param("moveCamera", true, "Move Camera", "Toggle if the camera should move to the middle.")
}
},
new GameAction("riffTogether", "Custom Together Riff")
@ -240,24 +240,24 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("1JJ", new EntityTypes.Integer(-1, 24, 0), "E2 String (JJ)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("2JJ", new EntityTypes.Integer(-1, 24, 0), "A2 String (JJ)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("3JJ", new EntityTypes.Integer(-1, 24, 0), "D3 String (JJ)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("4JJ", new EntityTypes.Integer(-1, 24, 0), "G3 String (JJ)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("5JJ", new EntityTypes.Integer(-1, 24, 0), "B3 String (JJ)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("6JJ", new EntityTypes.Integer(-1, 24, 0), "E4 String (JJ)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("sampleJJ", Rockers.PremadeSamples.None, "Premade Sample (JJ)", "Use a premade sample?"),
new Param("pitchSampleJJ", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones (JJ)", "Pitch up the sample by X amount of semitones?"),
new Param("gcJJ", false, "Glee Club Guitar (JJ)", "Will JJ use the same guitar as in the glee club lessons?"),
new Param("1S", new EntityTypes.Integer(-1, 24, 0), "E2 String (Soshi)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("2S", new EntityTypes.Integer(-1, 24, 0), "A2 String (Soshi)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("3S", new EntityTypes.Integer(-1, 24, 0), "D3 String (Soshi)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("4S", new EntityTypes.Integer(-1, 24, 0), "G3 String (Soshi)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("5S", new EntityTypes.Integer(-1, 24, 0), "B3 String (Soshi)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("6S", new EntityTypes.Integer(-1, 24, 0), "E4 String (Soshi)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("sampleS", Rockers.PremadeSamples.None, "Premade Sample (Soshi)", "Use a premade sample?"),
new Param("pitchSampleS", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones (Soshi)", "Pitch up the sample by X amount of semitones?"),
new Param("gcS", false, "Glee Club Guitar (Soshi)", "Will Soshi use the same guitar as in the glee club lessons?")
new Param("1JJ", new EntityTypes.Integer(-1, 24, 0), "E2 String (JJ)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("2JJ", new EntityTypes.Integer(-1, 24, 0), "A2 String (JJ)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("3JJ", new EntityTypes.Integer(-1, 24, 0), "D3 String (JJ)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("4JJ", new EntityTypes.Integer(-1, 24, 0), "G3 String (JJ)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("5JJ", new EntityTypes.Integer(-1, 24, 0), "B3 String (JJ)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("6JJ", new EntityTypes.Integer(-1, 24, 0), "E4 String (JJ)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("sampleJJ", Rockers.PremadeSamples.None, "Premade Sample (JJ)", "Set if this riff should use a premade sample."),
new Param("pitchSampleJJ", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones (JJ)", "Set how many semitones the premade sample should be pitched up."),
new Param("gcJJ", false, "Glee Club Guitar (JJ)", "Toggle if JJ should use the same guitar as in the Glee Club guitar lessons in DS."),
new Param("1S", new EntityTypes.Integer(-1, 24, 0), "E2 String (Soshi)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("2S", new EntityTypes.Integer(-1, 24, 0), "A2 String (Soshi)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("3S", new EntityTypes.Integer(-1, 24, 0), "D3 String (Soshi)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("4S", new EntityTypes.Integer(-1, 24, 0), "G3 String (Soshi)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("5S", new EntityTypes.Integer(-1, 24, 0), "B3 String (Soshi)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("6S", new EntityTypes.Integer(-1, 24, 0), "E4 String (Soshi)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("sampleS", Rockers.PremadeSamples.None, "Premade Sample (Soshi)", "Set if this riff should use a premade sample."),
new Param("pitchSampleS", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones (Soshi)", "Set how many semitones the premade sample should be pitched up."),
new Param("gcS", false, "Glee Club Guitar (Soshi)", "Toggle if Soshi should use the same guitar as in the Glee Club guitar lessons in DS.")
}
},
new GameAction("riffTogetherEnd", "Custom Together End Riff")
@ -265,24 +265,24 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("1JJ", new EntityTypes.Integer(-1, 24, 0), "E2 String (JJ)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("2JJ", new EntityTypes.Integer(-1, 24, 0), "A2 String (JJ)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("3JJ", new EntityTypes.Integer(-1, 24, 0), "D3 String (JJ)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("4JJ", new EntityTypes.Integer(-1, 24, 0), "G3 String (JJ)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("5JJ", new EntityTypes.Integer(-1, 24, 0), "B3 String (JJ)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("6JJ", new EntityTypes.Integer(-1, 24, 0), "E4 String (JJ)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("sampleJJ", Rockers.PremadeSamples.None, "Premade Sample (JJ)", "Use a premade sample?"),
new Param("pitchSampleJJ", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones (JJ)", "Pitch up the sample by X amount of semitones?"),
new Param("gcJJ", false, "Glee Club Guitar (JJ)", "Will JJ use the same guitar as in the glee club lessons?"),
new Param("1S", new EntityTypes.Integer(-1, 24, 0), "E2 String (Soshi)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("2S", new EntityTypes.Integer(-1, 24, 0), "A2 String (Soshi)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("3S", new EntityTypes.Integer(-1, 24, 0), "D3 String (Soshi)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("4S", new EntityTypes.Integer(-1, 24, 0), "G3 String (Soshi)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("5S", new EntityTypes.Integer(-1, 24, 0), "B3 String (Soshi)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("6S", new EntityTypes.Integer(-1, 24, 0), "E4 String (Soshi)", "How many semitones up is this string pitched? If left at -1, this string will not play."),
new Param("sampleS", Rockers.PremadeSamples.None, "Premade Sample (Soshi)", "Use a premade sample?"),
new Param("pitchSampleS", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones (Soshi)", "Pitch up the sample by X amount of semitones?"),
new Param("gcS", false, "Glee Club Guitar (Soshi)", "Will Soshi use the same guitar as in the glee club lessons?")
new Param("1JJ", new EntityTypes.Integer(-1, 24, 0), "E2 String (JJ)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("2JJ", new EntityTypes.Integer(-1, 24, 0), "A2 String (JJ)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("3JJ", new EntityTypes.Integer(-1, 24, 0), "D3 String (JJ)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("4JJ", new EntityTypes.Integer(-1, 24, 0), "G3 String (JJ)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("5JJ", new EntityTypes.Integer(-1, 24, 0), "B3 String (JJ)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("6JJ", new EntityTypes.Integer(-1, 24, 0), "E4 String (JJ)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("sampleJJ", Rockers.PremadeSamples.None, "Premade Sample (JJ)", "Set if this riff should use a premade sample."),
new Param("pitchSampleJJ", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones (JJ)", "Set how many semitones the premade sample should be pitched up."),
new Param("gcJJ", false, "Glee Club Guitar (JJ)", "Toggle if JJ should use the same guitar as in the Glee Club guitar lessons in DS."),
new Param("1S", new EntityTypes.Integer(-1, 24, 0), "E2 String (Soshi)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("2S", new EntityTypes.Integer(-1, 24, 0), "A2 String (Soshi)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("3S", new EntityTypes.Integer(-1, 24, 0), "D3 String (Soshi)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("4S", new EntityTypes.Integer(-1, 24, 0), "G3 String (Soshi)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("5S", new EntityTypes.Integer(-1, 24, 0), "B3 String (Soshi)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("6S", new EntityTypes.Integer(-1, 24, 0), "E4 String (Soshi)", "Set how many semitones up the current string will be pitched. If this is left at -1, this string will not play."),
new Param("sampleS", Rockers.PremadeSamples.None, "Premade Sample (Soshi)", "Set if this riff should use a premade sample."),
new Param("pitchSampleS", new EntityTypes.Integer(-24, 24, 0), "Sample Semtiones (Soshi)", "Set how many semitones the premade sample should be pitched up."),
new Param("gcS", false, "Glee Club Guitar (Soshi)", "Toggle if Soshi should use the same guitar as in the Glee Club guitar lessons in DS.")
}
},
},

2
Assets/Scripts/Games/Rockers/RockersRocker.cs
View file

@ -126,7 +126,7 @@ namespace HeavenStudio.Games.Scripts_Rockers
float pitch = SoundByte.GetPitchFromSemiTones(pitches[i], true);
float volume = GetVolumeBasedOnAmountOfStrings(pitches.Length);
string soundName = "rockers/strings/" + (gleeClub ? "gleeClub/" : "normal/" + (i + 1));
Debug.Log("Pitch: " + pitch + " Volume: " + volume + " Name: " + soundName);
// Debug.Log("Pitch: " + pitch + " Volume: " + volume + " Name: " + soundName);
stringSounds[i] = SoundByte.PlayOneShotGame(soundName, -1, pitch, volume, true);
}
}

1
Assets/Scripts/Games/SamuraiSliceNtr/NtrSamuraiObject.cs
View file

@ -177,7 +177,6 @@ namespace HeavenStudio.Games.Scripts_NtrSamurai
default: // object initial spawn, flying towards board
flyPos = cond.GetPositionFromBeat(launchProg.startBeat, 3f);
Debug.Log(flyPos);
transform.position = currentCurve.GetPoint(Mathf.Clamp01(flyPos));
if (flyPos >= 1)
transform.rotation = Quaternion.identity;

40
Assets/Scripts/Games/SamuraiSliceNtr/SamuraiSliceNtr.cs
View file

@ -19,12 +19,12 @@ namespace HeavenStudio.Games.Loaders
{
new GameAction("bop", "Bop")
{
function = delegate {var e = eventCaller.currentEntity; SamuraiSliceNtr.instance.Bop(e.beat, e.length, e["whoBops"], e["whoBopsAuto"]); },
function = delegate {var e = eventCaller.currentEntity; SamuraiSliceNtr.instance.Bop(e.beat, e.length, e["bop"], e["bopAuto"]); },
resizable = true,
parameters = new List<Param>()
{
new Param("whoBops", SamuraiSliceNtr.WhoBops.Both, "Who Bops?", "Who will bop?"),
new Param("whoBopsAuto", SamuraiSliceNtr.WhoBops.None, "Who Bops? (Auto)", "Who will automatically begin bopping?")
new Param("bop", true, "Bop", "Toggle if the child should bop for the duration of this event."),
new Param("bopAuto", false, "Bop (Auto)", "Toggle if the child should automatically bop until another Bop event is reached.")
}
},
new GameAction("melon", "Melon")
@ -36,8 +36,8 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 5,
parameters = new List<Param>()
{
new Param("2b2t", false, "Melon2B2T", "Should the melon be reskinned as the 2B2T melon?"),
new Param("valA", new EntityTypes.Integer(0, 30, 1), "Money", "The amount of coins the melon spills out when sliced"),
new Param("2b2t", false, "Voxel Melon", "Toggle if the melon should be reskinned as a melon from a certain game."),
new Param("valA", new EntityTypes.Integer(0, 30, 1), "Money", "Set the amount of coins the melon spills out when sliced."),
}
},
new GameAction("fish", "Fish")
@ -49,7 +49,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 7,
parameters = new List<Param>()
{
new Param("valA", new EntityTypes.Integer(0, 30, 1), "Money", "The amount of coins the fish spills out when sliced"),
new Param("valA", new EntityTypes.Integer(0, 30, 1), "Money", "Set the amount of coins the fish spills out when sliced."),
}
},
new GameAction("demon", "Demon")
@ -61,7 +61,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 7,
parameters = new List<Param>()
{
new Param("valA", new EntityTypes.Integer(0, 30, 1), "Money", "The amount of coins the demon spills out when sliced"),
new Param("valA", new EntityTypes.Integer(0, 30, 1), "Money", "Set the amount of coins the demon spills out when sliced."),
}
},
//backwards compatibility
@ -167,17 +167,12 @@ namespace HeavenStudio.Games
private void Awake()
{
instance = this;
SetupBopRegion("samuraiSliceNtr", "bop", "whoBopsAuto", false);
SetupBopRegion("samuraiSliceNtr", "bop", "bopAuto", false);
}
public override void OnBeatPulse(double beat)
{
int whoBopsAuto = BeatIsInBopRegionInt(beat);
bool goBopSamurai = whoBopsAuto == (int)WhoBops.Samurai || whoBopsAuto == (int)WhoBops.Both;
bool goBopChild = whoBopsAuto == (int)WhoBops.Children || whoBopsAuto == (int)WhoBops.Both;
if (goBopSamurai) player.Bop();
if (goBopChild) childParent.GetComponent<NtrSamuraiChild>().Bop();
if (BeatIsInBopRegion(beat)) childParent.GetComponent<NtrSamuraiChild>().Bop();
}
void Update()
@ -190,7 +185,7 @@ namespace HeavenStudio.Games
DoSlice();
}
public void Bop(double beat, float length, int whoBops, int whoBopsAuto)
public void Bop(double beat, float length, bool whoBops, bool whoBopsAuto)
{
for (int i = 0; i < length; i++)
{
@ -201,22 +196,11 @@ namespace HeavenStudio.Games
}
}
void BopSingle(int whoBops)
void BopSingle(bool whoBops)
{
switch (whoBops)
if (whoBops)
{
case (int)WhoBops.Samurai:
player.Bop();
break;
case (int)WhoBops.Children:
childParent.GetComponent<NtrSamuraiChild>().Bop();
break;
case (int)WhoBops.Both:
player.Bop();
childParent.GetComponent<NtrSamuraiChild>().Bop();
break;
default:
break;
}
}

151
Assets/Scripts/Games/SeeSaw/SeeSaw.cs
View file

@ -13,76 +13,6 @@ namespace HeavenStudio.Games.Loaders
{
return new Minigame("seeSaw", "See-Saw", "ffb4f7", false, false, new List<GameAction>()
{
new GameAction("longLong", "Long Long")
{
function = delegate { var e = eventCaller.currentEntity; SeeSaw.instance.cameraMove = e["camMove"]; SeeSaw.instance.LongLong(e.beat, e["high"], e["height"]); },
defaultLength = 4f,
parameters = new List<Param>()
{
new Param("high", false, "High", "Will they perform high jumps?", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (bool)x, new string[] { "height", "camMove" })
}),
new Param("height", new EntityTypes.Float(0, 1, 0), "Height", "Controls how high the high jump will go, 0 is the minimum height, 1 is the maximum height."),
new Param("camMove", true, "Camera Movement", "Will the camera follow saw when it jumps up high?")
}
},
new GameAction("longShort", "Long Short")
{
function = delegate { var e = eventCaller.currentEntity; SeeSaw.instance.cameraMove = e["camMove"]; SeeSaw.instance.LongShort(e.beat, e["high"], e["height"]); },
defaultLength = 3f,
parameters = new List<Param>()
{
new Param("high", false, "High", "Will they perform high jumps?", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (bool)x, new string[] { "height", "camMove" })
}),
new Param("height", new EntityTypes.Float(0, 1, 0), "Height", "Controls how high the high jump will go, 0 is the minimum height, 1 is the maximum height."),
new Param("camMove", true, "Camera Movement", "Will the camera follow saw when it jumps up high?")
}
},
new GameAction("shortLong", "Short Long")
{
function = delegate { var e = eventCaller.currentEntity; SeeSaw.instance.cameraMove = e["camMove"]; SeeSaw.instance.ShortLong(e.beat, e["high"], e["height"]); },
defaultLength = 3f,
parameters = new List<Param>()
{
new Param("high", false, "High", "Will they perform high jumps?", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (bool)x, new string[] { "height", "camMove" })
}),
new Param("height", new EntityTypes.Float(0, 1, 0), "Height", "Controls how high the high jump will go, 0 is the minimum height, 1 is the maximum height."),
new Param("camMove", true, "Camera Movement", "Will the camera follow saw when it jumps up high?")
}
},
new GameAction("shortShort", "Short Short")
{
function = delegate { var e = eventCaller.currentEntity; SeeSaw.instance.cameraMove = e["camMove"]; SeeSaw.instance.ShortShort(e.beat, e["high"], e["height"]); },
defaultLength = 2f,
parameters = new List<Param>()
{
new Param("high", false, "High", "Will they perform high jumps?", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (bool)x, new string[] { "height", "camMove" })
}),
new Param("height", new EntityTypes.Float(0, 1, 0), "Height", "Controls how high the high jump will go, 0 is the minimum height, 1 is the maximum height."),
new Param("camMove", true, "Camera Movement", "Will the camera follow saw when it jumps up high?")
}
},
new GameAction("changeBgColor", "Change Background Color")
{
function = delegate { var e = eventCaller.currentEntity; SeeSaw.instance.ChangeColor(e.beat, e.length, e["colorFrom"], e["colorTo"], e["colorFrom2"], e["colorTo2"], e["ease"]); },
defaultLength = 4f,
resizable = true,
parameters = new List<Param>()
{
new Param("colorFrom", SeeSaw.defaultBGColor, "Start Color (Top)", "The color the background will start at."),
new Param("colorTo", SeeSaw.defaultBGColor, "End Color (Top)", "The color the background will end at."),
new Param("colorFrom2", SeeSaw.defaultBGColorBottom, "Start Color (Bottom)", "The color the background will start at."),
new Param("colorTo2", SeeSaw.defaultBGColorBottom, "End Color (Bottom)", "The color the background will end at."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "The ease of the fade.")
}
},
new GameAction("bop", "Bop")
{
function = delegate { var e = eventCaller.currentEntity; SeeSaw.instance.Bop(e.beat, e.length, e["bopSee"], e["bopSaw"], e["autoSee"], e["autoSaw"], e["strumSee"], e["strumSaw"]); },
@ -98,15 +28,85 @@ namespace HeavenStudio.Games.Loaders
new Param("strumSaw", false, "Saw Strum", "Should saw do the strum bop?"),
}
},
new GameAction("choke", "Choke")
new GameAction("longLong", "Long Long")
{
function = delegate { var e = eventCaller.currentEntity; SeeSaw.instance.cameraMove = e["camMove"]; SeeSaw.instance.LongLong(e.beat, e["high"], e["height"]); },
defaultLength = 4f,
parameters = new List<Param>()
{
new Param("high", false, "High", "Toggle if the jumps should be high jumps.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (bool)x, new string[] { "height", "camMove" })
}),
new Param("height", new EntityTypes.Float(0, 1, 0), "Height", "Set how high the high jumps will go. 0 is the minimum height, and 1 is the maximum height."),
new Param("camMove", true, "Camera Movement", "Toggle if the camera will follow Saw when they jump.")
}
},
new GameAction("longShort", "Long Short")
{
function = delegate { var e = eventCaller.currentEntity; SeeSaw.instance.cameraMove = e["camMove"]; SeeSaw.instance.LongShort(e.beat, e["high"], e["height"]); },
defaultLength = 3f,
parameters = new List<Param>()
{
new Param("high", false, "High", "Toggle if the jumps should be high jumps.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (bool)x, new string[] { "height", "camMove" })
}),
new Param("height", new EntityTypes.Float(0, 1, 0), "Height", "Set how high the high jumps will go. 0 is the minimum height, and 1 is the maximum height."),
new Param("camMove", true, "Camera Movement", "Toggle if the camera will follow Saw when they jump.")
}
},
new GameAction("shortLong", "Short Long")
{
function = delegate { var e = eventCaller.currentEntity; SeeSaw.instance.cameraMove = e["camMove"]; SeeSaw.instance.ShortLong(e.beat, e["high"], e["height"]); },
defaultLength = 3f,
parameters = new List<Param>()
{
new Param("high", false, "High", "Toggle if the jumps should be high jumps.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (bool)x, new string[] { "height", "camMove" })
}),
new Param("height", new EntityTypes.Float(0, 1, 0), "Height", "Set how high the high jumps will go. 0 is the minimum height, and 1 is the maximum height."),
new Param("camMove", true, "Camera Movement", "Toggle if the camera will follow Saw when they jump.")
}
},
new GameAction("shortShort", "Short Short")
{
function = delegate { var e = eventCaller.currentEntity; SeeSaw.instance.cameraMove = e["camMove"]; SeeSaw.instance.ShortShort(e.beat, e["high"], e["height"]); },
defaultLength = 2f,
parameters = new List<Param>()
{
new Param("high", false, "High", "Toggle if the jumps should be high jumps.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (bool)x, new string[] { "height", "camMove" })
}),
new Param("height", new EntityTypes.Float(0, 1, 0), "Height", "Set how high the high jumps will go. 0 is the minimum height, and 1 is the maximum height."),
new Param("camMove", true, "Camera Movement", "Toggle if the camera will follow Saw when they jump.")
}
},
new GameAction("choke", "Strum")
{
function = delegate { var e = eventCaller.currentEntity; SeeSaw.instance.Choke(e.beat, e.length, e["see"], e["saw"]); },
defaultLength = 4f,
resizable = true,
parameters = new List<Param>()
{
new Param("see", true, "See", "Will See Choke?"),
new Param("saw", true, "Saw", "Will Saw Choke?")
new Param("see", true, "See", "Toggle if See will strum and explode."),
new Param("saw", true, "Saw", "Toggle if Saw will strum and explode.")
}
},
new GameAction("changeBgColor", "Background Appearance")
{
function = delegate { var e = eventCaller.currentEntity; SeeSaw.instance.ChangeColor(e.beat, e.length, e["colorFrom"], e["colorTo"], e["colorFrom2"], e["colorTo2"], e["ease"]); },
defaultLength = 4f,
resizable = true,
parameters = new List<Param>()
{
new Param("colorFrom", SeeSaw.defaultBGColor, "Color A Start", "Set the top-most color of the background gradient at the start of the event."),
new Param("colorTo", SeeSaw.defaultBGColor, "Color A End", "Set the top-most color of the background gradient at the end of the event."),
new Param("colorFrom2", SeeSaw.defaultBGColorBottom, "Color B Start", "Set the bottom-most color of the background gradient at the start of the event."),
new Param("colorTo2", SeeSaw.defaultBGColorBottom, "Color B End", "Set the bottom-most color of the background gradient at the end of the event."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.")
}
},
new GameAction("recolor", "Color Pallete")
@ -115,8 +115,8 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("outline", SeeSaw.defaultOtherColor, "Outline Color", "The color of the outlines on see and saw."),
new Param("fill", Color.white, "Fill Color", "The color of the fills on see and saw")
new Param("outline", SeeSaw.defaultOtherColor, "Outline Color", "Set the color used for the outlines."),
new Param("fill", Color.white, "Fill Color", "Set the color used for the fill.")
}
}
},
@ -285,7 +285,6 @@ namespace HeavenStudio.Games
private void GrabJumpEvents(double beat)
{
Debug.Log("Beat: " + beat);
var jumpEvents = EventCaller.GetAllInGameManagerList("seeSaw", new string[] { "longLong", "longShort", "shortLong", "shortShort" });
List<RiqEntity> tempEvents = new List<RiqEntity>();
for (int i = 0; i < jumpEvents.Count; i++)

30
Assets/Scripts/Games/SneakySpirits/SneakySpirits.cs
View file

@ -29,21 +29,16 @@ namespace HeavenStudio.Games.Loaders
},
parameters = new List<Param>()
{
new Param("slowDown", true, "Slowdown Effect", "Should there be a slowdown effect when the ghost is hit?"),
new Param("volume1", new EntityTypes.Integer(0, 100, 100), "Move Volume 1", "What height and what volume should this move be at?"),
new Param("volume2", new EntityTypes.Integer(0, 100, 100), "Move Volume 2", "What height and what volume should this move be at?"),
new Param("volume3", new EntityTypes.Integer(0, 100, 100), "Move Volume 3", "What height and what volume should this move be at?"),
new Param("volume4", new EntityTypes.Integer(0, 100, 100), "Move Volume 4", "What height and what volume should this move be at?"),
new Param("volume5", new EntityTypes.Integer(0, 100, 100), "Move Volume 5", "What height and what volume should this move be at?"),
new Param("volume6", new EntityTypes.Integer(0, 100, 100), "Move Volume 6", "What height and what volume should this move be at?"),
new Param("volume7", new EntityTypes.Integer(0, 100, 100), "Move Volume 7", "What height and what volume should this move be at?"),
new Param("slowDown", true, "Slowdown Effect", "Toggle if there should be a slowdown effect when the ghost is hit."),
new Param("volume1", new EntityTypes.Integer(0, 100, 100), "Move Volume 1", "Set the height and volume the ghost should have at this position."),
new Param("volume2", new EntityTypes.Integer(0, 100, 100), "Move Volume 2", "Set the height and volume the ghost should have at this position."),
new Param("volume3", new EntityTypes.Integer(0, 100, 100), "Move Volume 3", "Set the height and volume the ghost should have at this position."),
new Param("volume4", new EntityTypes.Integer(0, 100, 100), "Move Volume 4", "Set the height and volume the ghost should have at this position."),
new Param("volume5", new EntityTypes.Integer(0, 100, 100), "Move Volume 5", "Set the height and volume the ghost should have at this position."),
new Param("volume6", new EntityTypes.Integer(0, 100, 100), "Move Volume 6", "Set the height and volume the ghost should have at this position."),
new Param("volume7", new EntityTypes.Integer(0, 100, 100), "Move Volume 7", "Set the height and volume the ghost should have at this position."),
}
},
new GameAction("forceReload", "Bow Force Reload")
{
function = delegate { SneakySpirits.instance.ForceReload(); },
defaultLength = 1f,
},
new GameAction("movebow", "Bow Enter or Exit")
{
function = delegate {var e = eventCaller.currentEntity; SneakySpirits.instance.MoveBow(e.beat, e.length, e["exit"], e["ease"]); },
@ -51,10 +46,15 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("exit", true, "Enter?", "Should the bow exit or enter?"),
new Param("ease", EasingFunction.Ease.Linear, "Ease", "Which ease should the movement have?")
new Param("exit", true, "Enter", "Toggle if the bow should enter or exit the scene."),
new Param("ease", EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.")
}
},
new GameAction("forceReload", "Bow Force Reload")
{
function = delegate { SneakySpirits.instance.ForceReload(); },
defaultLength = 1f,
},
},
new List<string>() {"agb", "aim"},
"agbghost", "en",

54
Assets/Scripts/Games/SpaceDance/SpaceDance.cs
View file

@ -13,6 +13,19 @@ namespace HeavenStudio.Games.Loaders
public static Minigame AddGame(EventCaller eventCaller) {
return new Minigame("spaceDance", "Space Dance", "0014d6", false, false, new List<GameAction>()
{
new GameAction("bop", "Bop")
{
function = delegate { var e = eventCaller.currentEntity; SpaceDance.instance.EpicBop(e.beat, e.length, e["auto"], e["bop"], e["grampsAuto"], e["gramps"]); },
parameters = new List<Param>()
{
new Param("bop", true, "Dancers Bop", "Toggle if the dancers should bop for the duration of this event."),
new Param("auto", false, "Dancers Bop (Auto)", "Toggle if the dancers should automatically bop until another Bop event is reached."),
new Param("gramps", false, "Gramps Bop", "Toggle if Space Gramps should bop for the duration of this event."),
new Param("grampsAuto", false, "Gramps Bop (Auto)", "Toggle if Space Gramps should automatically bop until another Bop event is reached.")
},
resizable = true,
defaultLength = 4f
},
new GameAction("turn right", "Turn Right")
{
function = delegate { var e = eventCaller.currentEntity; SpaceDance.instance.DoTurnRight(e.beat, e["gramps"]); },
@ -20,8 +33,8 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 2.0f,
parameters = new List<Param>()
{
new Param("whoSpeaks", SpaceDance.WhoSpeaks.Dancers, "Who Speaks?", "Who will say the voice line for the cue?"),
new Param("gramps", false, "Space Gramps Animations", "Will Space Gramps turn right?")
new Param("whoSpeaks", SpaceDance.WhoSpeaks.Dancers, "Speaker", "Choose who will say the voice line."),
new Param("gramps", false, "Space Gramps Animations", "Toggle if Space Gramps will turn right with the dancers.")
}
},
new GameAction("sit down", "Sit Down")
@ -31,8 +44,8 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 2.0f,
parameters = new List<Param>()
{
new Param("whoSpeaks", SpaceDance.WhoSpeaks.Dancers, "Who Speaks?", "Who will say the voice line for the cue?"),
new Param("gramps", false, "Space Gramps Animations", "Will Space Gramps turn right?")
new Param("whoSpeaks", SpaceDance.WhoSpeaks.Dancers, "Speaker", "Choose who will say the voice line."),
new Param("gramps", false, "Space Gramps Animations", "Toggle if Space Gramps will sit down with the dancers.")
}
},
new GameAction("punch", "Punch")
@ -42,8 +55,8 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 2.0f,
parameters = new List<Param>()
{
new Param("whoSpeaks", SpaceDance.WhoSpeaks.Dancers, "Who Speaks?", "Who will say the voice line for the cue?"),
new Param("gramps", false, "Space Gramps Animations", "Will Space Gramps turn right?")
new Param("whoSpeaks", SpaceDance.WhoSpeaks.Dancers, "Speaker", "Choose who will say the voice line."),
new Param("gramps", false, "Space Gramps Animations", "Toggle if Space Gramps will punch with the dancers.")
}
},
new GameAction("shootingStar", "Shooting Star")
@ -53,7 +66,7 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("ease", EasingFunction.Ease.Linear, "Ease", "Which ease should the shooting of the stars use?")
new Param("ease", EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.")
}
},
new GameAction("changeBG", "Change Background Color")
@ -63,32 +76,19 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("start", SpaceDance.defaultBGColor, "Start Color", "The start color for the fade or the color that will be switched to if -instant- is ticked on."),
new Param("end", SpaceDance.defaultBGColor, "End Color", "The end color for the fade."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease")
new Param("start", SpaceDance.defaultBGColor, "Start Color", "Set the color at the start of the event."),
new Param("end", SpaceDance.defaultBGColor, "End Color", "Set the color at the end of the event."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.")
}
},
new GameAction("bop", "Bop")
{
function = delegate { var e = eventCaller.currentEntity; SpaceDance.instance.EpicBop(e.beat, e.length, e["auto"], e["bop"], e["grampsAuto"], e["gramps"]); },
parameters = new List<Param>()
{
new Param("bop", true, "Dancers Bop", "Should the dancers bop?"),
new Param("auto", false, "Dancers Bop (Auto)", "Should the dancers auto bop?"),
new Param("gramps", false, "Gramps Bop", "Should Space Gramps bop with the dancers?"),
new Param("grampsAuto", false, "Gramps Bop (Auto)", "Should Space Gramps auto bop with the dancers?")
},
resizable = true,
defaultLength = 4f
},
new GameAction("grampsAnims", "Space Gramps Animations")
{
function = delegate {var e = eventCaller.currentEntity; SpaceDance.instance.GrampsAnimations(e.beat, e["type"], e["toggle"]); },
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("toggle", true, "Looping", "Should the animation loop?"),
new Param("type", SpaceDance.GrampsAnimationType.Talk, "Which animation?", "Which animation should space gramps do?")
new Param("toggle", true, "Loop", "Toggle if the animation should loop."),
new Param("type", SpaceDance.GrampsAnimationType.Talk, "Animation", "Set the animation for Space Gramps to perform.")
}
},
new GameAction("scroll", "Scrolling Background")
@ -96,8 +96,8 @@ namespace HeavenStudio.Games.Loaders
function = delegate { var e = eventCaller.currentEntity; SpaceDance.instance.UpdateScrollSpeed(e["x"], e["y"]); },
defaultLength = 1f,
parameters = new List<Param>() {
new Param("x", new EntityTypes.Float(-10f, 10f, 0), "Horizontal", "How fast does the background move horizontally?"),
new Param("y", new EntityTypes.Float(-10f, 10f, 0), "Vertical", "How fast does the background move vertically?"),
new Param("x", new EntityTypes.Float(-10f, 10f, 0), "Horizontal Speed", "Set how fast the background will scroll horizontally."),
new Param("y", new EntityTypes.Float(-10f, 10f, 0), "Vertical Speed", "Set how fast the background will scroll vertically."),
}
},
},

2
Assets/Scripts/Games/SpaceSoccer/Ball.cs
View file

@ -81,8 +81,6 @@ namespace HeavenStudio.Games.Scripts_SpaceSoccer
}
else
{
highKickSwing = highKicks[i]["swing"];
if (highKickSwing == 0f)
highKickSwing = 0.5f;
if (highKicks[i].beat + GetAnimLength(State.HighKicked) > currentBeat)

2
Assets/Scripts/Games/SpaceSoccer/Kicker.cs
View file

@ -253,8 +253,6 @@ namespace HeavenStudio.Games.Scripts_SpaceSoccer
if (ball)
{
ball.highKickSwing = highKicks[i]["swing"];
if (ball.highKickSwing == 0f)
ball.highKickSwing = 0.5f;
}
break;

75
Assets/Scripts/Games/SpaceSoccer/SpaceSoccer.cs
View file

@ -17,13 +17,13 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 2f,
parameters = new List<Param>()
{
new Param("toggle", false, "Disable Sound", "Disables the dispense sound"),
new Param("down", false, "Down Sound", "Will the Down sound be played?"),
new Param("auto", true, "Auto Redispense", "", new()
new Param("toggle", false, "Disable Sound", "Toggle if the dispense sound should be disabled."),
new Param("down", false, "Down Sound", "Toggle if the \"Down!\" cue from Remix 9 (DS) should be played."),
new Param("auto", true, "Auto Redispense", "Toggle if a ball should automatically be redispensed if the player lets it fall.", new()
{
new((x, _) => (bool)x, new string[] { "interval" })
}),
new("interval", new EntityTypes.Integer(2, 20, 2), "Redispense Interval")
new("interval", new EntityTypes.Integer(2, 20, 2), "Redispense Interval", "Set how many beats it should take for a ball to be redispensed.")
},
inactiveFunction = delegate
{
@ -33,45 +33,40 @@ namespace HeavenStudio.Games.Loaders
new GameAction("high kick-toe!", "High Kick-Toe!")
{
defaultLength = 3f,
parameters = new List<Param>()
{
new Param("swing", new EntityTypes.Float(0, 1, 0.5f), "Swing", "The amount of swing")
}
},
new GameAction("npc kickers enter or exit", "NPC Kickers Enter or Exit")
new GameAction("npc kickers enter or exit", "NPC Kickers")
{
function = delegate { var e = eventCaller.currentEntity; SpaceSoccer.instance.NPCKickersEnterOrExit(e.beat, e.length, e["choice"], e["ease"], e["amount"], e["x"], e["y"], e["z"], e["override"], e["preset"]); },
function = delegate { var e = eventCaller.currentEntity; SpaceSoccer.instance.NPCKickersEnterOrExit(e.beat, e.length, e["choice"], e["ease"], e["amount"], e["x"], e["y"], e["z"], true, e["preset"]); },
defaultLength = 4f,
parameters = new List<Param>()
{
new Param("preset", SpaceSoccer.EnterExitPresets.FiveKickers, "Preset", "Which preset should be used?", new List<Param.CollapseParam>()
new Param("preset", SpaceSoccer.EnterExitPresets.FiveKickers, "Preset", "Choose a preset for the NPCs.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (int)x == (int)SpaceSoccer.EnterExitPresets.Custom, new string[] { "amount", "x", "y", "z" })
}),
new Param("amount", new EntityTypes.Integer(2, 30, 5), "Amount", "Amount of Space Kickers."),
new Param("x", new EntityTypes.Float(-30, 30, 2f), "X Distance", "How much distance should there be between the space kickers on the x axis?"),
new Param("y", new EntityTypes.Float(-30, 30, -0.5f), "Y Distance", "How much distance should there be between the space kickers on the y axis?"),
new Param("z", new EntityTypes.Float(-30, 30, 1.25f), "Z Distance", "How much distance should there be between the space kickers on the z axis?"),
new Param("amount", new EntityTypes.Integer(2, 30, 5), "Amount", "Set the amount of space kickers."),
new Param("x", new EntityTypes.Float(-30, 30, 2f), "X Distance", "Set how much distance there should be between the space kickers on the x axis."),
new Param("y", new EntityTypes.Float(-30, 30, -0.5f), "Y Distance", "Set how much distance there should be between the space kickers on the x axis."),
new Param("z", new EntityTypes.Float(-30, 30, 1.25f), "Z Distance", "Set how much distance there should be between the space kickers on the x axis."),
new Param("choice", SpaceSoccer.AnimationToPlay.Enter, "Enter Or Exit", "Whether the kickers should exit or enter."),
new Param("ease", EasingFunction.Ease.Linear, "Ease", "The Ease of the entering or exiting."),
new Param("override", true, "Override Easing", "Should this block override the easing of the space kickers' positions?")
new Param("choice", SpaceSoccer.AnimationToPlay.Enter, "Status", "Choose if the kickers should enter or exit."),
new Param("ease", EasingFunction.Ease.Linear, "Ease", "Set the easing of the action."),
},
resizable = true
},
new GameAction("easePos", "Ease NPC Space Kicker Distances")
new GameAction("easePos", "Change NPC Distances")
{
function = delegate {var e = eventCaller.currentEntity; SpaceSoccer.instance.EaseSpaceKickersPositions(e.beat, e.length, e["ease"], e["x"], e["y"], e["z"]); },
defaultLength = 4f,
resizable = true,
parameters = new List<Param>()
{
new Param("x", new EntityTypes.Float(-30, 30, 2f), "X Distance", "How much distance should there be between the space kickers on the x axis?"),
new Param("y", new EntityTypes.Float(-30, 30, -0.5f), "Y Distance", "How much distance should there be between the space kickers on the y axis?"),
new Param("z", new EntityTypes.Float(-30, 30, 1.25f), "Z Distance", "How much distance should there be between the space kickers on the z axis?"),
new Param("ease", EasingFunction.Ease.Linear, "Ease", "The Ease of the space kickers moving."),
new Param("x", new EntityTypes.Float(-30, 30, 2f), "X Distance", "Set how much distance there should be between the space kickers on the x axis."),
new Param("y", new EntityTypes.Float(-30, 30, -0.5f), "Y Distance", "Set how much distance there should be between the space kickers on the x axis."),
new Param("z", new EntityTypes.Float(-30, 30, 1.25f), "Z Distance", "Set how much distance there should be between the space kickers on the x axis."),
new Param("ease", EasingFunction.Ease.Linear, "Ease", "Set the easing of the action."),
}
},
new GameAction("pMove", "Move Player")
@ -81,29 +76,29 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("preset", SpaceSoccer.PlayerPresets.LaunchStart, "Preset", "Which preset should be used?", new List<Param.CollapseParam>()
new Param("preset", SpaceSoccer.PlayerPresets.LaunchStart, "Preset", "Choose a preset for the player.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (int)x == (int)SpaceSoccer.PlayerPresets.Custom, new string[] { "x", "y", "z", "ease", "sound" })
}),
new Param("x", new EntityTypes.Float(-30, 30, 0f), "X Pos", "Which position should the player move to on the x axis?"),
new Param("y", new EntityTypes.Float(-30, 30, 0f), "Y Pos", "Which position should the player move to on the y axis?"),
new Param("z", new EntityTypes.Float(-30, 30, 0f), "Z Pos", "Which position should the player move to on the z axis?"),
new Param("ease", EasingFunction.Ease.Linear, "Ease", "The Ease of the space kickers moving."),
new Param("sound", SpaceSoccer.LaunchSoundToPlay.None, "Sound", "Which launch sound should be played at the start of this block?")
new Param("x", new EntityTypes.Float(-30, 30, 0f), "X Position", "Set the position the player should move to on the x axis."),
new Param("y", new EntityTypes.Float(-30, 30, 0f), "Y Position", "Set the position the player should move to on the y axis."),
new Param("z", new EntityTypes.Float(-30, 30, 0f), "Z Position", "Set the position the player should move to on the z axis."),
new Param("ease", EasingFunction.Ease.Linear, "Ease", "Set the easing of the action."),
new Param("sound", SpaceSoccer.LaunchSoundToPlay.None, "Sound", "Set the launch sound to be played at the start of this event.")
}
},
new GameAction("changeBG", "Change Background Color")
new GameAction("changeBG", "Background Appearance")
{
function = delegate {var e = eventCaller.currentEntity; SpaceSoccer.instance.BackgroundColor(e.beat, e.length, e["start"], e["end"], e["startDots"], e["endDots"], e["ease"]); },
defaultLength = 1f,
resizable = true,
parameters = new List<Param>()
{
new Param("start", SpaceSoccer.defaultBGColor, "Start Color", "The start color for the fade or the color that will be switched to if -instant- is ticked on."),
new Param("end", SpaceSoccer.defaultBGColor, "End Color", "The end color for the fade."),
new Param("startDots", Color.white, "Start Color (Dots)", "The start color for the fade or the color that will be switched to if -instant- is ticked on."),
new Param("endDots", Color.white, "End Color (Dots)", "The end color for the fade."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease")
new Param("start", SpaceSoccer.defaultBGColor, "Start Color", "Set the color at the start of the event."),
new Param("end", SpaceSoccer.defaultBGColor, "End Color", "Set the color at the end of the event."),
new Param("startDots", Color.white, "Start Color (Dots)", "Set the color at the start of the event."),
new Param("endDots", Color.white, "End Color (Dots)", "Set the color at the end of the event."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.")
}
},
new GameAction("scroll", "Scrolling Background")
@ -111,16 +106,16 @@ namespace HeavenStudio.Games.Loaders
function = delegate { var e = eventCaller.currentEntity; SpaceSoccer.instance.UpdateScrollSpeed(e["x"], e["y"]); },
defaultLength = 1f,
parameters = new List<Param>() {
new Param("x", new EntityTypes.Float(-10f, 10, 0.1f), "Horizontal", "How fast does the background move horizontally?"),
new Param("y", new EntityTypes.Float(-10, 10f, 0.3f), "Vertical", "How fast does the background move vertically?"),
new Param("x", new EntityTypes.Float(-10f, 10, 0.1f), "Horizontal Speed", "Set how fast the background will scroll horizontally."),
new Param("y", new EntityTypes.Float(-10, 10f, 0.3f), "Vertical Speed", "Set how fast the background will scroll vertically."),
}
},
new GameAction("stopBall", "Stop Ball")
new GameAction("stopBall", "Remove Ball")
{
function = delegate { SpaceSoccer.instance.StopBall(eventCaller.currentEntity["toggle"]); },
parameters = new List<Param>()
{
new Param("toggle", true, "Stop ball?", "Should the ball be stopped? If ticked off the kickers will regain their ability to use the ball.")
new Param("toggle", true, "Remove", "Toggle if the ball should be removed and the kickers shouldn't be able to kick. To re-enable kicks, place this event again and disable this property.")
}
},
// This is still here for "backwards-compatibility" but is hidden in the editor (it does absolutely nothing however)
@ -307,14 +302,12 @@ namespace HeavenStudio.Games
{
if (hitBeats.Exists(x => x == offsetBeat - 0.5)) return;
ScoreMiss();
Debug.Log("Miss toe");
}
}
else if (!IsExpectingInputNow(InputAction_BasicPress))
{
if (hitBeats.Exists(x => offsetBeat == x)) return;
ScoreMiss();
Debug.Log("Miss");
}
}

16
Assets/Scripts/Games/Spaceball/Spaceball.cs
View file

@ -21,7 +21,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 2,
parameters = new List<Param>()
{
new Param("type", Spaceball.BallType.Baseball, "Type", "The type of ball/object to shoot")
new Param("type", Spaceball.BallType.Baseball, "Type", "Set the object to shoot.")
}
},
new GameAction("shootHigh", "Pitch High Ball")
@ -32,23 +32,23 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 3,
parameters = new List<Param>()
{
new Param("type", Spaceball.BallType.Baseball, "Type", "The type of ball/object to shoot")
new Param("type", Spaceball.BallType.Baseball, "Type", "Set the object to shoot.")
}
},
new GameAction("costume", "Change Batter Costume")
new GameAction("costume", "Batter Costume")
{
function = delegate { Spaceball.instance.Costume(eventCaller.currentEntity["type"]); },
parameters = new List<Param>()
{
new Param("type", Spaceball.CostumeType.Standard, "Type", "The costume to change to")
new Param("type", Spaceball.CostumeType.Standard, "Type", "Set the costume for the batter to wear.")
}
},
new GameAction("alien", "Show Alien")
new GameAction("alien", "Space Umpire Animation")
{
function = delegate { Spaceball.instance.alien.Show(eventCaller.currentEntity.beat, eventCaller.currentEntity["hide"]); },
parameters = new List<Param>()
{
new Param("hide", false, "Hide", "Should the alien be hidden?")
new Param("hide", false, "Hide", "Toggle if Space Umpire should be hidden from the scene.")
}
},
new GameAction("camera", "Zoom Camera")
@ -57,8 +57,8 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("valA", new EntityTypes.Integer(1, 320, 10), "Zoom", "The camera's zoom level (Lower value = Zoomed in)"),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "The easing function to use while zooming")
new Param("valA", new EntityTypes.Integer(1, 320, 10), "Zoom", "Set the level to zoom to."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.")
}
},
new GameAction("prepare dispenser", "Dispenser Prepare")

12
Assets/Scripts/Games/Splashdown/Splashdown.cs
View file

@ -26,7 +26,7 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("type", new EntityTypes.Integer(1, 3, 1), "Type")
new Param("type", new EntityTypes.Integer(1, 3, 1), "Type", "Set the type of animation to play when surfacing.")
}
},
new GameAction("jump", "Jump")
@ -36,7 +36,7 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("dolphin", true, "Dolphin")
new Param("dolphin", true, "Dolphin", "Toggle if the dolphin should be used.")
}
},
new GameAction("together", "Together Jump")
@ -45,7 +45,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 4f,
parameters = new List<Param>()
{
new Param("al", false, "Alley-Oop!")
new Param("al", false, "Alley-Oop!", "Toggle if the \"Alley-Oop!\" sound effect and animation should be used.")
}
},
new GameAction("togetherR9", "Together Jump (Remix 9)")
@ -54,7 +54,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 3f,
parameters = new List<Param>()
{
new Param("al", false, "Alley-Oop!")
new Param("al", false, "Alley-Oop!", "Toggle if the \"Alley-Oop!\" sound effect and animation should be used.")
}
},
new GameAction("intro", "Intro")
@ -63,13 +63,13 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
defaultLength = 8
},
new GameAction("amount", "Synchrette Amount")
new GameAction("amount", "Change Synchrette Number")
{
function = delegate { Splashdown.instance.SpawnSynchrettes(eventCaller.currentEntity["amount"], eventCaller.currentEntity.beat); },
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("amount", new EntityTypes.Integer(3, 5, 3), "Amount")
new Param("amount", new EntityTypes.Integer(3, 5, 3), "Synchrettes", "Set how many synchrettes there will be. The player is always the rightmost synchrette.")
}
}
},

30
Assets/Scripts/Games/Tambourine/Tambourine.cs
View file

@ -14,6 +14,17 @@ namespace HeavenStudio.Games.Loaders
{
return new Minigame("tambourine", "Tambourine", "388cd0", false, false, new List<GameAction>()
{
new GameAction("bop", "Bop")
{
function = delegate {var e = eventCaller.currentEntity; Tambourine.instance.Bop(e.beat, e.length, e["whoBops"], e["whoBopsAuto"]); },
parameters = new List<Param>()
{
new Param("whoBops", Tambourine.WhoBops.Both, "Bop", "Set the character(s) to bop for the duration of this event."),
new Param("whoBopsAuto", Tambourine.WhoBops.None, "Bop (Auto)", "Set the character(s) to automatically bop until another Bop event is reached."),
},
resizable = true,
priority = 4
},
new GameAction("beat intervals", "Start Interval")
{
preFunction = delegate {var e = eventCaller.currentEntity; Tambourine.PreInterval(e.beat, e.length, e["auto"]); },
@ -21,7 +32,7 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("auto", true, "Auto Pass Turn")
new Param("auto", true, "Auto Pass Turn", "Toggle if the turn should be passed automatically at the end of the start interval.")
}
},
new GameAction("shake", "Shake")
@ -41,17 +52,6 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
preFunctionLength = 1f
},
new GameAction("bop", "Bop")
{
function = delegate {var e = eventCaller.currentEntity; Tambourine.instance.Bop(e.beat, e.length, e["whoBops"], e["whoBopsAuto"]); },
parameters = new List<Param>()
{
new Param("whoBops", Tambourine.WhoBops.Both, "Who Bops", "Who will bop."),
new Param("whoBopsAuto", Tambourine.WhoBops.None, "Who Bops (Auto)", "Who will auto bop."),
},
resizable = true,
priority = 4
},
new GameAction("success", "Success")
{
function = delegate {var e = eventCaller.currentEntity; Tambourine.instance.SuccessFace(e.beat); },
@ -65,9 +65,9 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("colorStart", Color.white, "Start Color", "The starting color of the fade."),
new Param("colorEnd", Tambourine.defaultBGColor, "End Color", "The ending color of the fade."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease")
new Param("colorStart", Color.white, "Start Color", "Set the color at the start of the event."),
new Param("colorEnd", Tambourine.defaultBGColor, "End Color", "Set the color at the end of the event."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.")
}
},
},

18
Assets/Scripts/Games/TapTrial/TapTrial.cs
View file

@ -19,8 +19,8 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("toggle", true, "Bop", "Whether both will bop to the beat or not"),
new Param("toggle2", false, "Bop (Auto)", "Whether both will bop automatically to the beat or not")
new Param("toggle", true, "Bop", "Toggle if the characters should bop for the duration of this event."),
new Param("toggle2", false, "Bop (Auto)", "Toggle if the characters should automatically bop until another Bop event is reached.")
}
},
new GameAction("tap", "Tap")
@ -38,7 +38,7 @@ namespace HeavenStudio.Games.Loaders
function = delegate { TapTrial.instance.TripleTap(eventCaller.currentEntity.beat); },
defaultLength = 4.0f
},
new GameAction("jump tap prep", "Prepare Stance")
new GameAction("jump tap prep", "Jump Prepare")
{
function = delegate { TapTrial.instance.JumpPrepare(); },
},
@ -48,7 +48,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 2.0f,
parameters = new List<Param>()
{
new Param("final", false, "Final")
new Param("final", false, "Final", "Toggle if this jump should be the final one of the set.")
}
},
new GameAction("scroll event", "Scroll Background")
@ -57,12 +57,12 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 1f,
parameters = new List<Param>()
{
new Param("toggle", true, "Scroll FX", "Will scroll", new List<Param.CollapseParam>()
new Param("toggle", true, "Scroll", "Toggle if the background should scroll.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (bool)x, new string[] { "flash", "m"})
}),
new Param("flash", true, "Flash FX", "Will flash to white"),
new Param("m", new EntityTypes.Float(0, 10, 1), "Speed Multiplier")
new Param("flash", true, "White Fade", "Toggle if the background will have a white overlay."),
new Param("m", new EntityTypes.Float(0, 10, 1), "Speed", "Set how fast the background should scroll.")
}
},
new GameAction("giraffe events", "Giraffe Animations")
@ -71,8 +71,8 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("toggle", TapTrial.GiraffeAnimation.Enter, "Animation", "Which animation?"),
new Param("instant", EasingFunction.Ease.Linear, "Ease", "Which ease will be used?")
new Param("toggle", TapTrial.GiraffeAnimation.Enter, "Animation", "Set the animation for the giraffe to perform."),
new Param("instant", EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.")
}
},
// backwards-compatibility

52
Assets/Scripts/Games/TapTroupe/TapTroupe.cs
View file

@ -14,6 +14,16 @@ namespace HeavenStudio.Games.Loaders
{
return new Minigame("tapTroupe", "Tap Troupe", "999999", false, false, new List<GameAction>()
{
new GameAction("bop", "Bop")
{
function = delegate {var e = eventCaller.currentEntity; TapTroupe.instance.Bop(e.beat, e.length, e["bop"], e["bopAuto"]); },
resizable = true,
parameters = new List<Param>()
{
new Param("bop", true, "Bop", "Toggle if the tall tappers should bop for the duration of this event."),
new Param("bopAuto", false, "Bop (Auto)", "Toggle if the tall tappers should automatically bop until another Bop event is reached.")
}
},
new GameAction("stepping", "Stepping")
{
preFunction = delegate { var e = eventCaller.currentEntity; TapTroupe.PreStepping(e.beat, e.length, e["startTap"]); },
@ -21,7 +31,7 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("startTap", false, "Start Tap Voice Line", "Whether or not it should say -Tap!- on the first step.")
new Param("startTap", false, "Tap Voice Line", "Toggle if the \"Tap!\" voice line should be played on the first tap.")
}
},
new GameAction("tapping", "Tapping")
@ -31,60 +41,50 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("okay", true, "Okay Voice Line", "Whether or not the tappers should say -Okay!- after successfully tapping.", new List<Param.CollapseParam>()
new Param("okay", true, "OK", "Toggle if the tall tappers should say \"OK!\" after successfully tapping.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (bool)x, new string[] { "okayType" })
}),
new Param("okayType", TapTroupe.OkayType.OkayA, "Okay Type", "Which version of the okay voice line should the tappers say?"),
new Param("animType", TapTroupe.OkayAnimType.Normal, "Okay Animation", "Which animations should be played when the tapper say OK?", new List<Param.CollapseParam>()
new Param("okayType", TapTroupe.OkayType.OkayA, "Type", "Set the version of the voice line the tall tappers should say."),
new Param("animType", TapTroupe.OkayAnimType.Normal, "Animation", "Set the animation that should be played when the tall tappers say \"OK!\"", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (int)x == (int)TapTroupe.OkayAnimType.Popper, new string[]{ "popperBeats"})
}),
new Param("popperBeats", new EntityTypes.Float(0f, 80f, 2f), "Popper Beats", "How many beats until the popper will pop?"),
new Param("popperBeats", new EntityTypes.Float(0f, 80f, 2f), "Popper Beats", "Set how many beats it should take for the party popper to pop."),
new Param("randomVoiceLine", true, "Extra Random Voice Line", "Whether there should be randomly said woos or laughs after the tappers say OK!"),
new Param("noReady", false, "Mute Ready")
new Param("noReady", false, "Mute Ready", "Toggle if the \"Rea-dy!\" cue should be muted.")
}
},
new GameAction("bop", "Bop")
{
function = delegate {var e = eventCaller.currentEntity; TapTroupe.instance.Bop(e.beat, e.length, e["bop"], e["bopAuto"]); },
resizable = true,
parameters = new List<Param>()
{
new Param("bop", true, "Bop", "Should the tappers bop?"),
new Param("bopAuto", false, "Bop (Auto)", "Should the tappers auto bop?")
}
},
new GameAction("spotlights", "Toggle Spotlights")
new GameAction("spotlights", "Spotlights")
{
function = delegate {var e = eventCaller.currentEntity; TapTroupe.instance.Spotlights(e["toggle"], e["player"], e["middleLeft"], e["middleRight"], e["leftMost"]); },
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("toggle", true, "Darkness On", "Whether or not it should be dark."),
new Param("player", true, "Player Spotlight", "Whether or not the player spotlight should be turned on or off."),
new Param("middleRight", false, "Middleright Tapper Spotlight", "Whether or not the middleright tapper spotlight should be turned on or off."),
new Param("middleLeft", false, "Middleleft Tapper Spotlight", "Whether or not the middleleft tapper spotlight should be turned on or off."),
new Param("leftMost", false, "Leftmost Tapper Spotlight", "Whether or not the leftmost tapper spotlight should be turned on or off."),
new Param("toggle", true, "Darkness", "Toggle if the scene should be dark and the spotlights should appear."),
new Param("leftMost", false, "Leftmost Spotlight", "Toggle if the leftmost spotlight should be turned on or off."),
new Param("middleLeft", false, "Middle-Left Spotlight", "Toggle if the middle-left spotlight should be turned on or off."),
new Param("middleRight", false, "Middle-Light Spotlight", "Toggle if the middle-right spotlight should be turned on or off."),
new Param("player", true, "Player Spotlight", "Toggle if the player's spotlight should be turned on or off."),
}
},
new GameAction("zoomOut", "Special Zoom Out")
new GameAction("zoomOut", "Zoom Out")
{
function = delegate { TapTroupe.instance.ToggleZoomOut(); },
defaultLength = 4f,
resizable = true,
parameters = new List<Param>()
{
new Param("ease", Util.EasingFunction.Ease.EaseOutQuad, "Camera Ease", "What ease should the camera use?"),
new Param("ease", Util.EasingFunction.Ease.EaseOutQuad, "Ease", "Set the easing of the action."),
},
},
new GameAction("tutorialMissFace", "Toggle Tutorial Miss Face")
new GameAction("tutorialMissFace", "Tutorial Miss Face")
{
function = delegate { var e = eventCaller.currentEntity; TapTroupe.instance.ToggleMissFace(e["toggle"]); },
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("toggle", true, "Use it?", "Use the faces they do when you miss in the tutorial of Tap Troupe?")
new Param("toggle", true, "Tutorial Miss Face", "Toggle if the NPC tappers should use the miss face as seen in the original tutorial.")
}
}
},

61
Assets/Scripts/Games/TheDazzles/TheDazzles.cs
View file

@ -15,13 +15,23 @@ namespace HeavenStudio.Games.Loaders
{
return new Minigame("theDazzles", "The Dazzles", "9cfff7", false, false, new List<GameAction>()
{
new GameAction("bop", "Bop")
{
function = delegate { var e = eventCaller.currentEntity; TheDazzles.instance.Bop(e.beat, e.length, e["toggle2"], e["toggle"]); },
resizable = true,
parameters = new List<Param>()
{
new Param("toggle2", true, "Bop", "Toggle if the dazzles should bop for the duration of this event."),
new Param("toggle", false, "Bop (Auto)", "Toggle if the dazzles should automatically bop until another Bop event is reached.")
}
},
new GameAction("crouch", "Crouch")
{
preFunction = delegate { var e = eventCaller.currentEntity; TheDazzles.PreCrouch(e.beat, e.length, e["countIn"]); },
defaultLength = 3f,
parameters = new List<Param>()
{
new Param("countIn", TheDazzles.CountInType.DS, "Count In Type", "Should the count-In be from megamix, DS or random?")
new Param("countIn", TheDazzles.CountInType.DS, "Count In Type", "Set if the count-in should be from Megamix, DS or random.")
}
},
new GameAction("crouchStretch", "Crouch (Stretchable)")
@ -31,7 +41,7 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("countIn", TheDazzles.CountInType.DS, "Count In Type", "Should the count-In be from megamix, DS or random?")
new Param("countIn", TheDazzles.CountInType.DS, "Count In Type", "Set if the count-in should be from Megamix, DS or random.")
}
},
new GameAction("poseThree", "Pose Horizontal")
@ -40,8 +50,8 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 3f,
parameters = new List<Param>()
{
new Param("toggle", false, "Stars", "Should stars appear when successfully posing?"),
new Param("toggle2", true, "Cheer Sounds")
new Param("toggle", false, "Stars", "Toggle if stars should appear when successfully posing."),
new Param("toggle2", true, "Cheer Sounds", "Toggle if cheering sounds should be played when successfully posing.")
}
},
new GameAction("poseTwo", "Pose Vertical")
@ -50,8 +60,8 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 4f,
parameters = new List<Param>()
{
new Param("toggle", true, "Stars", "Should stars appear when successfully posing?"),
new Param("toggle2", true, "Cheer Sounds")
new Param("toggle", true, "Stars", "Toggle if stars should appear when successfully posing."),
new Param("toggle2", true, "Cheer Sounds", "Toggle if cheering sounds should be played when successfully posing.")
}
},
new GameAction("poseSixDiagonal", "Pose Diagonal")
@ -60,8 +70,8 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 4.5f,
parameters = new List<Param>()
{
new Param("toggle", false, "Stars", "Should stars appear when successfully posing?"),
new Param("toggle2", true, "Cheer Sounds")
new Param("toggle", false, "Stars", "Toggle if stars should appear when successfully posing."),
new Param("toggle2", true, "Cheer Sounds", "Toggle if cheering sounds should be played when successfully posing.")
}
},
new GameAction("poseSixColumns", "Pose Rows")
@ -70,8 +80,8 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 4f,
parameters = new List<Param>()
{
new Param("toggle", false, "Stars", "Should stars appear when successfully posing?"),
new Param("toggle2", true, "Cheer Sounds")
new Param("toggle", false, "Stars", "Toggle if stars should appear when successfully posing."),
new Param("toggle2", true, "Cheer Sounds", "Toggle if cheering sounds should be played when successfully posing.")
}
},
new GameAction("poseSix", "Pose Six")
@ -80,8 +90,8 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 4.5f,
parameters = new List<Param>()
{
new Param("toggle", true, "Stars", "Should stars appear when successfully posing?"),
new Param("toggle2", true, "Cheer Sounds")
new Param("toggle", true, "Stars", "Toggle if stars should appear when successfully posing."),
new Param("toggle2", true, "Cheer Sounds", "Toggle if cheering sounds should be played when successfully posing.")
}
},
new GameAction("customPose", "Custom Pose")
@ -91,14 +101,14 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("upLeft", new EntityTypes.Float(0, 30f, 0f), "Up Left Girl Pose Beat", "How many beats after the event has started will this girl pose?"),
new Param("upMiddle", new EntityTypes.Float(0, 30f, 1f), "Up Middle Girl Pose Beat", "How many beats after the event has started will this girl pose?"),
new Param("upRight", new EntityTypes.Float(0, 30f, 2f), "Up Right Girl Pose Beat", "How many beats after the event has started will this girl pose?"),
new Param("downLeft", new EntityTypes.Float(0, 30f, 0f), "Down Left Girl Pose Beat", "How many beats after the event has started will this girl pose?"),
new Param("downMiddle", new EntityTypes.Float(0, 30f, 1f), "Down Middle Girl Pose Beat", "How many beats after the event has started will this girl pose?"),
new Param("player", new EntityTypes.Float(0, 30f, 2f), "Player Pose Beat", "How many beats after the event has started should the player pose?"),
new Param("toggle", false, "Stars", "Should stars appear when successfully posing?"),
new Param("toggle2", true, "Cheer Sounds")
new Param("upLeft", new EntityTypes.Float(0, 30f, 0f), "Up Left Girl Pose Beat", "Set how many beats after the event has started this girl will pose."),
new Param("upMiddle", new EntityTypes.Float(0, 30f, 1f), "Up Middle Girl Pose Beat", "Set how many beats after the event has started this girl will pose."),
new Param("upRight", new EntityTypes.Float(0, 30f, 2f), "Up Right Girl Pose Beat", "Set how many beats after the event has started this girl will pose."),
new Param("downLeft", new EntityTypes.Float(0, 30f, 0f), "Down Left Girl Pose Beat", "Set how many beats after the event has started this girl will pose."),
new Param("downMiddle", new EntityTypes.Float(0, 30f, 1f), "Down Middle Girl Pose Beat", "Set how many beats after the event has started this girl will pose."),
new Param("player", new EntityTypes.Float(0, 30f, 2f), "Player Pose Beat", "Set how many beats after the event has started the player will pose."),
new Param("toggle", false, "Stars", "Toggle if stars should appear when successfully posing."),
new Param("toggle2", true, "Cheer Sounds", "Toggle if cheering sounds should be played when successfully posing.")
}
},
new GameAction("forceHold", "Force Hold")
@ -106,17 +116,6 @@ namespace HeavenStudio.Games.Loaders
function = delegate { TheDazzles.instance.ForceHold(); },
defaultLength = 0.5f
},
new GameAction("bop", "Bop")
{
function = delegate { var e = eventCaller.currentEntity; TheDazzles.instance.Bop(e.beat, e.length, e["toggle2"], e["toggle"]); },
resizable = true,
parameters = new List<Param>()
{
new Param("toggle2", true, "Should bop?", "Should the dazzles bop?"),
new Param("toggle", false, "Should auto bop?", "Should the dazzles auto bop?")
}
},
},
new List<string>() {"ntr", "normal"},
"ntrboxshow", "en",

49
Assets/Scripts/Games/TossBoys/TossBoys.cs
View file

@ -12,8 +12,18 @@ namespace HeavenStudio.Games.Loaders
{
public static Minigame AddGame(EventCaller eventCaller)
{
return new Minigame("tossBoys", "Toss Boys", "9cfff7", false, false, new List<GameAction>()
return new Minigame("tossBoys", "Toss Boys \n<color=#adadad>(Tosu Bōizu)</color>", "9cfff7", false, false, new List<GameAction>()
{
new GameAction("bop", "Bop")
{
function = delegate { var e = eventCaller.currentEntity; TossBoys.instance.Bop(e.beat, e.length, e["auto"], e["bop"]); },
resizable = true,
parameters = new List<Param>()
{
new Param("bop", true, "Bop", "Toggle if the toss boys should bop for the duration of this event."),
new Param("auto", false, "Bop (Auto)", "Toggle if the toss boys should automatically bop until another Bop event is reached.")
}
},
new GameAction("dispense", "Dispense")
{
function = delegate { var e = eventCaller.currentEntity; TossBoys.instance.Dispense(e.beat, e.length, e["who"], e["auto"], e["interval"], e["ignore"], e["callAuto"], true, e["call"]); },
@ -22,17 +32,16 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("who", TossBoys.KidChoice.Akachan, "Receiver", "Who will receive the ball?"),
new Param("call", false, "Name Call", "Should the other kids than the receiver call their name?"),
new Param("who", TossBoys.KidChoice.Akachan, "Target", "Set who will receive the ball."),
new Param("call", false, "Name Call", "Toggle if the non-recieving kids should call the reciever's name."),
//auto dispense stuff
new Param("auto", true, "Auto Redispense", "", new()
new Param("auto", true, "Auto Redispense", "Toggle if a ball should automatically be redispensed if the player lets it pop prematurely.", new()
{
new((x, _) => (bool)x, new string[] { "interval", "ignore", "callAuto" })
}),
new Param("interval", new EntityTypes.Integer(1, 20, 2), "Redispense Interval", "Based on passes and not beats"),
new Param("ignore", true, "Ignore Special Passes"),
new Param("callAuto", false, "Name Call On Redispense")
new Param("interval", new EntityTypes.Integer(1, 20, 2), "Redispense Interval", "Set how many passes it should take for a ball to be redispensed."),
new Param("ignore", true, "Ignore Special Passes", "Toggle if the redispense interval should ignore special passes."),
new Param("callAuto", false, "Name Call On Redispense", "Toggle if the recieving kid's name should be called out when a ball is redispensed.")
}
},
new GameAction("pass", "Normal Toss")
@ -41,7 +50,7 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("who", TossBoys.KidChoice.Aokun, "Receiver", "Who will receive the ball?")
new Param("who", TossBoys.KidChoice.Aokun, "Target", "Set who will receive the ball.")
}
},
new GameAction("dual", "Dual Toss")
@ -50,7 +59,7 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("who", TossBoys.KidChoice.Akachan, "Receiver", "Who will receive the ball?")
new Param("who", TossBoys.KidChoice.Akachan, "Target", "Set who will receive the ball.")
}
},
new GameAction("high", "High Toss")
@ -59,7 +68,7 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("who", TossBoys.KidChoice.Kiiyan, "Receiver", "Who will receive the ball?")
new Param("who", TossBoys.KidChoice.Kiiyan, "Target", "Set who will receive the ball.")
}
},
new GameAction("lightning", "Lightning Toss")
@ -68,7 +77,7 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("who", TossBoys.KidChoice.Aokun, "Receiver", "Who will receive the ball?")
new Param("who", TossBoys.KidChoice.Aokun, "Target", "Set who will receive the ball.")
}
},
new GameAction("blur", "Blur Toss")
@ -79,16 +88,6 @@ namespace HeavenStudio.Games.Loaders
{
defaultLength = 1f,
},
new GameAction("bop", "Bop")
{
function = delegate { var e = eventCaller.currentEntity; TossBoys.instance.Bop(e.beat, e.length, e["auto"], e["bop"]); },
resizable = true,
parameters = new List<Param>()
{
new Param("bop", true, "Bop", "Should the toss boys bop to the beat?"),
new Param("auto", false, "Bop (Auto)", "Should the toss boys auto bop to the beat?")
}
},
new GameAction("changeBG", "Change Background Color")
{
function = delegate {var e = eventCaller.currentEntity; TossBoys.instance.BackgroundColor(e.beat, e.length, e["start"], e["end"], e["ease"]); },
@ -96,9 +95,9 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("start", TossBoys.defaultBGColor, "Start Color", "The start color for the fade or the color that will be switched to if -instant- is ticked on."),
new Param("end", TossBoys.defaultBGColor, "End Color", "The end color for the fade."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease")
new Param("start", TossBoys.defaultBGColor, "Start Color", "Set the color at the start of the event."),
new Param("end", TossBoys.defaultBGColor, "End Color", "Set the color at the end of the event."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.")
}
},
},

36
Assets/Scripts/Games/TramAndPauline/TramAndPauline.cs
View file

@ -11,35 +11,35 @@ namespace HeavenStudio.Games.Loaders
{
public static Minigame AddGame(EventCaller eventCaller)
{
return new Minigame("tramAndPauline", "Tram & Pauline", "adb5e7", "ca8b17", "c14fae", false, false, new List<GameAction>()
return new Minigame("tramAndPauline", "Tram & Pauline \n<color=#adadad>(Toran to Porin)</color>", "adb5e7", "ca8b17", "c14fae", false, false, new List<GameAction>()
{
new GameAction("prepare", "Prepare")
{
function = delegate { TramAndPauline.instance.Prepare(eventCaller.currentEntity.beat, (TramAndPauline.TramOrPauline)eventCaller.currentEntity["who"]); },
parameters = new List<Param>()
{
new Param("who", TramAndPauline.TramOrPauline.Pauline, "Who Prepares?")
new Param("who", TramAndPauline.TramOrPauline.Pauline, "Target", "Toggle who should prepare to jump.")
}
},
new GameAction("pauline", "Pauline")
{
function = delegate { TramAndPauline.instance.Jump(eventCaller.currentEntity.beat, TramAndPauline.TramOrPauline.Pauline, eventCaller.currentEntity["toggle"]); },
defaultLength = 2f,
parameters = new List<Param>()
{
new Param("toggle", false, "Audience Reaction")
}
},
new GameAction("tram", "Tram")
new GameAction("tram", "Tram Jump")
{
function = delegate { TramAndPauline.instance.Jump(eventCaller.currentEntity.beat, TramAndPauline.TramOrPauline.Tram, eventCaller.currentEntity["toggle"]); },
defaultLength = 2f,
parameters = new List<Param>()
{
new Param("toggle", false, "Audience Reaction")
new Param("toggle", false, "Audience Reaction", "Toggle if the audience should react on a sucessful hit.")
}
},
new GameAction("shape", "Change Transformation")
new GameAction("pauline", "Pauline Jump")
{
function = delegate { TramAndPauline.instance.Jump(eventCaller.currentEntity.beat, TramAndPauline.TramOrPauline.Pauline, eventCaller.currentEntity["toggle"]); },
defaultLength = 2f,
parameters = new List<Param>()
{
new Param("toggle", false, "Audience Reaction", "Toggle if the audience should react on a sucessful hit.")
}
},
new GameAction("shape", "Set Transformation")
{
function = delegate
{
@ -49,8 +49,8 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("pauline", true, "Pauline is a Fox?"),
new Param("tram", true, "Tram is a Fox?")
new Param("tram", true, "Fox Tram", "Toggle if Tram should be set to his fox transformation."),
new Param("pauline", true, "Fox Pauline", "Toggle if Pauline should be set to her fox transformation.")
}
},
new GameAction("curtains", "Curtains")
@ -64,8 +64,8 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("toggle", false, "Going Up?"),
new Param("ease", EasingFunction.Ease.Linear, "Ease")
new Param("toggle", false, "Rise", "Toggle if the curtains should rise or fall."),
new Param("ease", EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.")
}
}
},

24
Assets/Scripts/Games/TrickClass/TrickClass.cs
View file

@ -15,6 +15,16 @@ namespace HeavenStudio.Games.Loaders
{
return new Minigame("trickClass", "Trick on the Class", "ecede4", false, false, new List<GameAction>()
{
new GameAction("bop", "Bop")
{
function = delegate { var e = eventCaller.currentEntity; TrickClass.instance.Bop(e.beat, e.length, e["bop"], e["autoBop"]); },
resizable = true,
parameters = new List<Param>()
{
new Param("bop", true, "Bop", "Toggle if the girl and boy should bop for the duration of this event."),
new Param("autoBop", false, "Bop (Auto)", "Toggle if the girl and boy should automatically bop until another Bop event is reached.")
}
},
new GameAction("toss", "Toss Object")
{
preFunction = delegate
@ -25,11 +35,11 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 2,
parameters = new List<Param>()
{
new Param("obj", TrickClass.TrickObjTypeEditor.PaperBall, "Object", "Changes the object thrown at the player", new List<Param.CollapseParam>()
new Param("obj", TrickClass.TrickObjTypeEditor.PaperBall, "Object", "Choose the object that the girl should throw.", new List<Param.CollapseParam>()
{
new Param.CollapseParam((x, _) => (int)x == (int)TrickClass.TrickObjTypeEditor.Phone, new string[] { "nx" }),
}),
new Param("nx", false, "Switch", "Replace the phone with a Switch"),
new Param("nx", false, "Switch", "Toggle if the phone should be replaced with a Nintendo Switch."),
}
},
new GameAction("plane", "Plane")
@ -48,16 +58,6 @@ namespace HeavenStudio.Games.Loaders
},
defaultLength = 4,
},
new GameAction("bop", "Bop")
{
function = delegate { var e = eventCaller.currentEntity; TrickClass.instance.Bop(e.beat, e.length, e["bop"], e["autoBop"]); },
resizable = true,
parameters = new List<Param>()
{
new Param("bop", true, "Bop", "Should the girl and boy bop?"),
new Param("autoBop", false, "Bop (Auto)", "Should the girl and boy auto bop?")
}
},
new GameAction("chair", "Chair")
{
preFunction = delegate

4
Assets/Scripts/Games/Tunnel/Tunnel.cs
View file

@ -31,8 +31,8 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("duration", new EntityTypes.Float(0, 8, 2), "Fade Duration", "The duration of the volume fade in beats"),
new Param("volume", new EntityTypes.Float(0, 200, 10), "Volume", "The volume to fade to"),
new Param("duration", new EntityTypes.Float(0, 8, 2), "Fade Duration", "Set how long it takes for the volume to fade."),
new Param("volume", new EntityTypes.Float(0, 200, 10), "Volume", "Set the volume to fade to while in the tunnel."),
}
},
new GameAction("countin", "Count In")

2
Assets/Scripts/Games/WizardsWaltz/WizardsWaltz.cs
View file

@ -23,7 +23,7 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("auto", true, "Auto Pass Turn")
new Param("auto", true, "Auto Pass Turn", "Toggle if the turn should be passed automatically at the end of the start interval.")
},
preFunctionLength = 1
},

23
Assets/Scripts/Games/WorkingDough/WorkingDough.cs
View file

@ -20,7 +20,7 @@ namespace HeavenStudio.Games.Loaders
resizable = true,
parameters = new List<Param>()
{
new Param("auto", true, "Auto Pass Turn", "Will the turn automatically be passed at the end of this event?")
new Param("auto", true, "Auto Pass Turn", "Toggle if the turn should be passed automatically at the end of the start interval.")
}
},
new GameAction("small ball", "Small Ball")
@ -34,7 +34,7 @@ namespace HeavenStudio.Games.Loaders
priority = 1,
parameters = new List<Param>()
{
new Param("hasGandw", false, "Has Mr. Game & Watch")
new Param("hasGandw", false, "Mr. Game & Watch", "Toggle if Mr. Game & Watch should be riding on the ball.")
}
},
new GameAction("passTurn", "Pass Turn")
@ -42,16 +42,16 @@ namespace HeavenStudio.Games.Loaders
preFunction = delegate { WorkingDough.PrePassTurn(eventCaller.currentEntity.beat); },
preFunctionLength = 1
},
new GameAction("launch spaceship", "Launch Spaceship")
new GameAction("rise spaceship", "Rise Up Spaceship")
{
function = delegate { var e = eventCaller.currentEntity; WorkingDough.instance.LaunchShip(e.beat, e.length); },
function = delegate { var e = eventCaller.currentEntity; WorkingDough.instance.RiseUpShip(e.beat, e.length); },
defaultLength = 4f,
resizable = true,
priority = 0
},
new GameAction("rise spaceship", "Rise Up Spaceship")
new GameAction("launch spaceship", "Launch Spaceship")
{
function = delegate { var e = eventCaller.currentEntity; WorkingDough.instance.RiseUpShip(e.beat, e.length); },
function = delegate { var e = eventCaller.currentEntity; WorkingDough.instance.LaunchShip(e.beat, e.length); },
defaultLength = 4f,
resizable = true,
priority = 0
@ -62,7 +62,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 4f,
parameters = new List<Param>()
{
new Param("toggle", false, "Go Up?", "Toggle to go Up or Down.")
new Param("toggle", false, "Up", "Toggle if the dough dudes should go up or down.")
},
resizable = true,
priority = 0
@ -72,7 +72,7 @@ namespace HeavenStudio.Games.Loaders
function = delegate { var e = eventCaller.currentEntity; WorkingDough.instance.InstantElevation(e["toggle"]); },
parameters = new List<Param>()
{
new Param("toggle", true, "Go Up?", "Toggle to go Up or Down.")
new Param("toggle", true, "Up", "Toggle if the dough dudes should go up or down.")
},
defaultLength = 0.5f,
priority = 0
@ -83,7 +83,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 4f,
parameters = new List<Param>()
{
new Param("toggle", false, "Should exit?", "Toggle to make him leave or enter.")
new Param("toggle", false, "Exit", "Toggle if Mr. Game & Watch should exit or enter the scene.")
},
resizable = true,
priority = 0
@ -93,7 +93,7 @@ namespace HeavenStudio.Games.Loaders
function = delegate { var e = eventCaller.currentEntity; WorkingDough.instance.InstantGANDWEnterOrExit(e["toggle"]); },
parameters = new List<Param>()
{
new Param("toggle", false, "Exit?", "Toggle to make him leave or enter.")
new Param("toggle", false, "Exit", "Toggle if Mr. Game & Watch should exit or enter the scene.")
},
defaultLength = 0.5f,
priority = 0
@ -104,7 +104,7 @@ namespace HeavenStudio.Games.Loaders
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("ship", false, "Spaceship Only", "Will only the spaceship be affected by this event?")
new Param("ship", false, "Spaceship Only", "Toggle if the only the spaceship should be toggled.")
}
}
},
@ -298,7 +298,6 @@ namespace HeavenStudio.Games
}
if (isBig) hasBigBall = true;
}
Debug.Log(autoPassTurn);
if (autoPassTurn)
{
PassTurn(beat + interval, interval, beat);

114
Assets/Scripts/LevelEditor/Timeline/Timeline.cs
View file

@ -338,7 +338,6 @@ namespace HeavenStudio.Editor.Track
public void CreateWaveform()
{
Debug.Log("what");
// DrawWaveform();
// StartCoroutine(DrawWaveformRealtime());
}
@ -970,119 +969,6 @@ namespace HeavenStudio.Editor.Track
CommandManager.Instance.AddCommand(new Commands.Paste(CopiedEntities));
}
/*
public TimelineEventObj AddEventObject(string eventName, bool dragNDrop = false, Vector3 pos = new Vector3(), RiqEntity entity = null, bool addEvent = false)
{
var game = EventCaller.instance.GetMinigame(eventName.Split(0));
var action = EventCaller.instance.GetGameAction(game, eventName.Split(1));
GameObject g = Instantiate(TimelineEventObjRef.gameObject, TimelineEventObjRef.parent);
g.transform.localPosition = pos;
TimelineEventObj eventObj = g.GetComponent<TimelineEventObj>();
eventObj.eventLabel.text = action.displayName;
if (eventName.Split(1) == "switchGame")
eventObj.Icon.sprite = Editor.GameIcon(eventName.Split(2));
else
eventObj.Icon.sprite = Editor.GameIcon(eventName.Split(0));
Minigames.GameAction gameAction = EventCaller.instance.GetGameAction(EventCaller.instance.GetMinigame(eventName.Split(0)), eventName.Split(1));
if (gameAction != null)
{
if (gameAction.resizable == false)
{
g.GetComponent<RectTransform>().sizeDelta = new Vector2(gameAction.defaultLength * Timeline.instance.PixelsPerBeat, LayerHeight());
float length = gameAction.defaultLength;
eventObj.length = length;
}
else
{
eventObj.resizable = true;
if (entity != null && gameAction.defaultLength != entity.length && dragNDrop == false)
{
g.GetComponent<RectTransform>().sizeDelta = new Vector2(entity.length * Timeline.instance.PixelsPerBeat, LayerHeight());
}
else
{
g.GetComponent<RectTransform>().sizeDelta = new Vector2(gameAction.defaultLength * Timeline.instance.PixelsPerBeat, LayerHeight());
}
}
}
if (dragNDrop)
{
var mousePos = Editor.instance.EditorCamera.ScreenToWorldPoint(Input.mousePosition);
g.transform.position = new Vector3(mousePos.x, mousePos.y, 0);
Selections.instance.ClickSelect(eventObj);
eventObj.moving = true;
}
else
{
entity["track"] = eventObj.GetTrack();
}
if (addEvent)
{
RiqEntity tempEntity = entity;
if (entity == null)
{
RiqEntity en = GameManager.instance.Beatmap.AddNewEntity(eventName, g.transform.localPosition.x, gameAction.defaultLength);
tempEntity = en;
// default param values
var ep = action.parameters;
if (ep != null)
{
for (int i = 0; i < ep.Count; i++)
{
object returnVal = ep[i].parameter;
var propertyType = returnVal.GetType();
if (propertyType == typeof(EntityTypes.Integer))
{
returnVal = ((EntityTypes.Integer)ep[i].parameter).val;
}
else if (propertyType == typeof(EntityTypes.Float))
{
returnVal = ((EntityTypes.Float)ep[i].parameter).val;
}
else if (propertyType.IsEnum)
{
returnVal = (int) ep[i].parameter;
}
//tempEntity[ep[i].propertyName] = returnVal;
tempEntity.CreateProperty(ep[i].propertyName, returnVal);
}
}
}
else
{
GameManager.instance.Beatmap.Entities.Add(tempEntity);
}
GameManager.instance.SortEventsList();
eventObj.entity = tempEntity;
}
else
{
eventObj.entity = entity;
}
eventObjs.Add(eventObj);
eventObj.eventObjID = eventObj.entity.uid;
g.SetActive(true);
return eventObj;
}
*/
private List<TimelineEventObj> duplicatedEventObjs = new List<TimelineEventObj>();
public TimelineEventObj CopyEventObject(TimelineEventObj e)
{

18
Assets/Scripts/LevelEditor/Timeline/TimelineEventObj.cs
View file

@ -60,11 +60,11 @@ namespace HeavenStudio.Editor.Track
private bool altWhenClicked = false;
private bool dragging = false;
private float initMoveX = 0.0f;
private float initMoveY = 0.0f;
private double initMoveX = 0;
private float initMoveY = 0;
private bool movedEntity = false;
private float lastBeat = 0.0f;
private double lastBeat = 0;
private int lastLayer = 0;
private int lastSiblingIndex;
@ -125,6 +125,12 @@ namespace HeavenStudio.Editor.Track
SetColor((int)entity["track"]);
SetWidthHeight();
selectedImage.gameObject.SetActive(false);
lastBeat = entity.beat;
initMoveX = 0.0f;
initMoveY = 0.0f;
lastResizeBeat = 0;
lastResizeLength = 0;
}
public void SetEntity(RiqEntity entity)
@ -232,7 +238,7 @@ namespace HeavenStudio.Editor.Track
{
foreach (var marker in Selections.instance.eventsSelected)
{
marker.entity.beat = Mathf.Max(Timeline.instance.MousePos2BeatSnap - marker.initMoveX, 0);
marker.entity.beat = System.Math.Max(Timeline.instance.MousePos2BeatSnap - marker.initMoveX, 0);
marker.entity["track"] = Mathf.Clamp(Timeline.instance.MousePos2Layer - marker.initMoveY, 0, Timeline.instance.LayerCount - 1);
marker.SetColor((int)entity["track"]);
marker.SetWidthHeight();
@ -281,10 +287,10 @@ namespace HeavenStudio.Editor.Track
foreach (var marker in Selections.instance.eventsSelected)
{
if (setMovedEntity) marker.movedEntity = true;
marker.lastBeat = (float)marker.entity.beat;
marker.lastBeat = marker.entity.beat;
marker.lastLayer = (int)marker.entity["track"];
marker.initMoveX = Timeline.instance.MousePos2BeatSnap - (float)marker.entity.beat;
marker.initMoveX = Timeline.instance.MousePos2BeatSnap - marker.entity.beat;
marker.initMoveY = Timeline.instance.MousePos2Layer - (int)marker.entity["track"];
}
}

6
Assets/Scripts/LevelEditor/Timeline/TimelineZoom.cs
View file

@ -44,7 +44,11 @@ namespace HeavenStudio.Editor.Track
Vector2 relativeMousePosition;
var cam = Editor.instance.EditorCamera;
if (cam == null) Debug.LogError("Camera not set!");
if (cam == null)
{
Debug.LogError("Camera not set!");
return;
}
RectTransformUtility.ScreenPointToLocalPointInRectangle(rectTransform, Input.mousePosition, cam, out relativeMousePosition);
if (scrollDeltaY > 0)

304
Assets/Scripts/Minigames.cs
View file

@ -740,7 +740,7 @@ namespace HeavenStudio
function: delegate { var e = eventCaller.currentEntity; GameManager.instance.SwitchGame(eventCaller.currentSwitchGame, eventCaller.currentEntity.beat, e["toggle"]); },
parameters: new List<Param>()
{
new Param("toggle", true, "Black Flash", "Enable or disable the black screen for this Game Switch")
new Param("toggle", true, "Black Flash", "Toggle if there should be a blck flash before the game is switched. You should only disable this if you know what you're doing.")
},
inactiveFunction: delegate { var e = eventCaller.currentEntity; GameManager.instance.SwitchGame(eventCaller.currentSwitchGame, eventCaller.currentEntity.beat, e["toggle"]); }
),
@ -764,7 +764,7 @@ namespace HeavenStudio
new GameAction("toggle inputs", "Toggle Inputs", 0.5f, true,
new List<Param>()
{
new Param("toggle", true, "Enable Inputs")
new Param("toggle", true, "Allow Inputs", "Toggle if the player is able to input. Any missed cues while this is disabled will not be counted as a miss and will not break a perfect.")
},
delegate
{
@ -807,22 +807,22 @@ namespace HeavenStudio
new GameAction("4 beat count-in", "4 Beat Count-In", 4f, true,
new List<Param>()
{
new Param("type", SoundEffects.CountInType.Normal, "Type", "The sounds to play for the count-in")
new Param("type", SoundEffects.CountInType.Normal, "Type", "Set the type of sounds to use for the count-in.")
},
delegate { var e = eventCaller.currentEntity; SoundEffects.FourBeatCountIn(e.beat, e.length / 4f, e["type"]); }
),
new GameAction("8 beat count-in", "8 Beat Count-In", 8f, true,
new List<Param>()
{
new Param("type", SoundEffects.CountInType.Normal, "Type", "The sounds to play for the count-in")
new Param("type", SoundEffects.CountInType.Normal, "Type", "Set the type of sounds to use for the count-in.")
},
delegate { var e = eventCaller.currentEntity; SoundEffects.EightBeatCountIn(e.beat, e.length / 8f, e["type"]); }
),
new GameAction("count", "Count", 1f, false,
new List<Param>()
{
new Param("type", SoundEffects.CountNumbers.One, "Number", "The sound to play"),
new Param("toggle", false, "Alt", "Whether or not the alternate version should be played")
new Param("type", SoundEffects.CountNumbers.One, "Type", "Set the number to say."),
new Param("toggle", false, "Alt", "Toggle if the alternate version of this voice line should be used.")
},
delegate { var e = eventCaller.currentEntity; SoundEffects.Count(e["type"], e["toggle"]); }
),
@ -838,7 +838,7 @@ namespace HeavenStudio
new GameAction("go!", "Go!", 1f, false,
new List<Param>()
{
new Param("toggle", false, "Alt", "Whether or not the alternate version should be played")
new Param("toggle", false, "Alt", "Toggle if the alternate version of this voice line should be used.")
},
function: delegate { SoundEffects.Go(eventCaller.currentEntity["toggle"]); }
),
@ -865,11 +865,11 @@ namespace HeavenStudio
new GameAction("flash", "Flash", 1f, true,
new List<Param>()
{
new Param("colorA", Color.white, "Start Color"),
new Param("colorB", Color.white, "End Color"),
new Param("valA", new EntityTypes.Float(0, 1, 1), "Start Opacity"),
new Param("valB", new EntityTypes.Float(0, 1, 0), "End Opacity"),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "", new()
new Param("colorA", Color.white, "Start Color", "Set the color at the start of the event."),
new Param("colorB", Color.white, "End Color", "Set the color at the end of the event."),
new Param("valA", new EntityTypes.Float(0, 1, 1), "Start Opacity", "Set the opacity at the start of the event."),
new Param("valB", new EntityTypes.Float(0, 1, 0), "End Opacity", "Set the opacity at the end of the event."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.", new()
{
new((x, y) => (Util.EasingFunction.Ease)x != Util.EasingFunction.Ease.Instant, new string[] { "colorA", "valA" })
})
@ -878,7 +878,7 @@ namespace HeavenStudio
new GameAction("filter", "Filter", 1f, true,
new List<Param>()
{
new Param("filter", Games.Global.Filter.FilterType.grayscale, "Filter"),
new Param("filter", Games.Global.Filter.FilterType.grayscale, "Type", "Set the type of filter to use."),
// old
/*new Param("inten", new EntityTypes.Float(0, 100, 100), "Intensity"),
@ -886,10 +886,10 @@ namespace HeavenStudio
new Param("fadeout", new EntityTypes.Float(0, 100, 0), "Fade Out")*/
// new
new Param("slot", new EntityTypes.Integer(1, 10, 1), "Slot", "Slot 1 is activated first and slot 10 last."),
new Param("start", new EntityTypes.Float(0, 1, 1), "Start Intensity"),
new Param("end", new EntityTypes.Float(0, 1, 1), "End Intensity"),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "", new()
new Param("slot", new EntityTypes.Integer(1, 10, 1), "Slot", "Set the slot for the filter. Higher slots are applied first. There can only be one filter per slot."),
new Param("start", new EntityTypes.Float(0, 1, 1), "Start Intensity", "Set the intensity at the start of the event."),
new Param("end", new EntityTypes.Float(0, 1, 1), "End Intensity", "Set the intensity at the end of the event."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.", new()
{
new((x, y) => (Util.EasingFunction.Ease)x != Util.EasingFunction.Ease.Instant, new string[] { "start" })
}),
@ -897,20 +897,42 @@ namespace HeavenStudio
),
new GameAction("move camera", "Move Camera", 1f, true, new List<Param>()
{
new Param("valA", new EntityTypes.Float(-50, 50, 0), "Right / Left", "Next position on the X axis"),
new Param("valB", new EntityTypes.Float(-50, 50, 0), "Up / Down", "Next position on the Y axis"),
new Param("valC", new EntityTypes.Float(-0, 250, 10), "In / Out", "Next position on the Z axis"),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease Type"),
new Param("axis", GameCamera.CameraAxis.All, "Axis", "The axis to move the camera on" )
new Param("valA", new EntityTypes.Float(-50, 50, 0), "Right / Left", "Set the position on the X axis."),
new Param("valB", new EntityTypes.Float(-50, 50, 0), "Up / Down", "Set the position on the Y axis."),
new Param("valC", new EntityTypes.Float(-0, 250, 10), "In / Out", "Set the position on the Z axis."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action."),
new Param("axis", GameCamera.CameraAxis.All, "Axis", "Set if only a specific axis should be modified." )
}
),
new GameAction("rotate camera", "Rotate Camera", 1f, true, new List<Param>()
{
new Param("valA", new EntityTypes.Integer(-360, 360, 0), "Pitch", "Next rotation on the X axis"),
new Param("valB", new EntityTypes.Integer(-360, 360, 0), "Yaw", "Next rotation on the Y axis"),
new Param("valC", new EntityTypes.Integer(-360, 360, 0), "Roll", "Next rotation on the Z axis"),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease Type"),
new Param("axis", GameCamera.CameraAxis.All, "Axis", "The axis to move the camera on" )
new Param("valA", new EntityTypes.Integer(-360, 360, 0), "Pitch", "Set the up/down rotation."),
new Param("valB", new EntityTypes.Integer(-360, 360, 0), "Yaw", "Set the left/right rotation."),
new Param("valC", new EntityTypes.Integer(-360, 360, 0), "Roll", "Set the clockwise/counterclockwise rotation."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action."),
new Param("axis", GameCamera.CameraAxis.All, "Axis", "Set if only a specific axis should be modified." )
}
),
new GameAction("pan view", "Pan Viewport", 1f, true, new List<Param>()
{
new Param("valA", new EntityTypes.Float(-50, 50, 0), "Right / Left", "Set the position on the X axis."),
new Param("valB", new EntityTypes.Float(-50, 50, 0), "Up / Down", "Set the position on the Y axis."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action."),
new Param("axis", StaticCamera.ViewAxis.All, "Axis", "Set if only a specific axis should be modified." )
}
),
new GameAction("rotate view", "Rotate Viewport", 1f, true, new List<Param>()
{
new Param("valA", new EntityTypes.Float(-360, 360, 0), "Rotation", "Set the clockwise/counterclockwise rotation."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action."),
}
),
new GameAction("scale view", "Scale Viewport", 1f, true, new List<Param>()
{
new Param("valA", new EntityTypes.Float(0, 50, 1), "Width", "Set the width of the viewport."),
new Param("valB", new EntityTypes.Float(0, 50, 1), "Height", "Set the height of the viewport."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action."),
new Param("axis", StaticCamera.ViewAxis.All, "Axis", "Set if only a specific axis should be modified." )
}
),
new("stretch camera", "Stretch Camera")
@ -918,87 +940,77 @@ namespace HeavenStudio
resizable = true,
parameters = new()
{
new("x1", new EntityTypes.Float(0f, 50f, 1f), "Start Width"),
new("y1", new EntityTypes.Float(0f, 50f, 1f), "Start Height"),
new("x2", new EntityTypes.Float(0f, 50f, 1f), "End Width"),
new("y2", new EntityTypes.Float(0f, 50f, 1f), "End Height"),
new("ease", Util.EasingFunction.Ease.Linear, "Ease", "", new()
new("x1", new EntityTypes.Float(0f, 50f, 1f), "Start Width", "Set the width at the start of the event."),
new("x2", new EntityTypes.Float(0f, 50f, 1f), "End Width", "Set the width at the end of the event."),
new("y1", new EntityTypes.Float(0f, 50f, 1f), "Start Height", "Set the height at the start of the event."),
new("y2", new EntityTypes.Float(0f, 50f, 1f), "End Height", "Set the height at the end of the event."),
new("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.", new()
{
new((x, y) => (Util.EasingFunction.Ease)x != Util.EasingFunction.Ease.Instant, new string[] { "x1", "y1" })
}),
new Param("axis", GameCamera.CameraAxis.All, "Axis")
new Param("axis", GameCamera.CameraAxis.All, "Axis", "Set if only a specific axis should be modified.")
}
},
new GameAction("camera background color", "Camera Background Color", 1, true, new List<Param>()
new GameAction("fitScreen", "Force Game Stretching To Window")
{
new Param("color", Color.black, "Start Color"),
new Param("color2", Color.black, "End Color"),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease Type")
}
),
new GameAction("pan view", "Pan Viewport", 1f, true, new List<Param>()
defaultLength = 0.5f,
parameters = new()
{
new Param("valA", new EntityTypes.Float(-50, 50, 0), "Right / Left", "Next position on the X axis"),
new Param("valB", new EntityTypes.Float(-50, 50, 0), "Up / Down", "Next position on the Y axis"),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease Type"),
new Param("axis", StaticCamera.ViewAxis.All, "Axis", "The axis to pan the viewport in" )
new("enable", true, "Enabled", "Toggle if the game should be forced to stretch to the window size, removing the letterbox.")
}
),
new GameAction("rotate view", "Rotate Viewport", 1f, true, new List<Param>()
{
new Param("valA", new EntityTypes.Float(-360, 360, 0), "Rotation", "Next viewport rotation"),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease Type"),
}
),
new GameAction("scale view", "Scale Viewport", 1f, true, new List<Param>()
{
new Param("valA", new EntityTypes.Float(0, 50, 1), "Width", "Next viewport width"),
new Param("valB", new EntityTypes.Float(0, 50, 1), "Height", "Next viewport height"),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease Type"),
new Param("axis", StaticCamera.ViewAxis.All, "Axis", "The axis to scale the viewport in" )
}
),
},
new GameAction("screen shake", "Screen Shake", 1f, true,
new List<Param>()
{
new Param("valA", new EntityTypes.Float(0, 10, 0), "Horizontal Intensity"),
new Param("valB", new EntityTypes.Float(0, 10, 1), "Vertical Intensity")
new Param("easedA", new EntityTypes.Float(0, 10, 0), "Start Horizontal Intensity", "Set the horizontal intensity of the screen shake at the start of the event."),
new Param("valA", new EntityTypes.Float(0, 10, 0), "End Horizontal Intensity", "Set the horizontal intensity of the screen shake at the end of the event."),
new Param("easedB", new EntityTypes.Float(0, 10, 0.5f), "Start Vertical Intensity", "Set the vertical intensity of the screen shake at the start of the event."),
new Param("valB", new EntityTypes.Float(0, 10, 0.5f), "End Vertical Intensity", "Set the vertical intensity of the screen shake at the end of the event."),
new("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.", new()
{
new((x, y) => (Util.EasingFunction.Ease)x != Util.EasingFunction.Ease.Instant, new string[] { "easedA", "easedB" })
}),
}
),
new GameAction("display textbox", "Display Textbox", 1f, true, new List<Param>()
{
new Param("text1", "", "Text", "The text to display in the textbox (Rich Text is supported!)"),
new Param("type", Games.Global.Textbox.TextboxAnchor.TopMiddle, "Anchor", "Where to anchor the textbox"),
new Param("valA", new EntityTypes.Float(0.25f, 4, 1), "Textbox Width", "Textbox width multiplier"),
new Param("valB", new EntityTypes.Float(0.5f, 8, 1), "Textbox Height", "Textbox height multiplier")
new Param("text1", "", "Text", "Set the text to display in the textbox. Rich text is supported."),
new Param("type", Games.Global.Textbox.TextboxAnchor.TopMiddle, "Anchor", "Set where to anchor the textbox."),
new Param("valA", new EntityTypes.Float(0.25f, 4, 1), "Width", "Set the width of the textbox."),
new Param("valB", new EntityTypes.Float(0.5f, 8, 1), "Height", "Set the height of the textbox.")
}
),
new GameAction("display open captions", "Display Open Captions", 1f, true,
new List<Param>()
{
new Param("text1", "", "Text", "The text to display in the captions (Rich Text is supported!)"),
new Param("type", Games.Global.Textbox.TextboxAnchor.BottomMiddle, "Anchor", "Where to anchor the captions"),
new Param("valA", new EntityTypes.Float(0.25f, 4, 1), "Captions Width", "Captions width multiplier"),
new Param("valB", new EntityTypes.Float(0.5f, 8, 1), "Captions Height", "Captions height multiplier")
new Param("text1", "", "Text", "Set the text to display in the captions. Rich text is supported."),
new Param("type", Games.Global.Textbox.TextboxAnchor.BottomMiddle, "Anchor", "Set where to anchor the captions."),
new Param("valA", new EntityTypes.Float(0.25f, 4, 1), "Width", "Set the width of the captions."),
new Param("valB", new EntityTypes.Float(0.5f, 8, 1), "Height", "Set the height of the captions.")
}
),
new GameAction("display closed captions", "Display Closed Captions", 1f, true,
new List<Param>()
{
new Param("text1", "", "Text", "The text to display in the captions (Rich Text is supported!)"),
new Param("type", Games.Global.Textbox.ClosedCaptionsAnchor.Top, "Anchor", "Where to anchor the captions"),
new Param("valA", new EntityTypes.Float(0.5f, 4, 1), "Captions Height", "Captions height multiplier")
new Param("text1", "", "Text", "Set the text to display in the captions. Rich text is supported."),
new Param("type", Games.Global.Textbox.ClosedCaptionsAnchor.Top, "Anchor", "Set where to anchor the captions."),
new Param("valA", new EntityTypes.Float(0.5f, 4, 1), "Height", "Set the height of the captions.")
}
),
new GameAction("display song artist", "Display Song Info", 1f, true,
new List<Param>()
{
new Param("text1", "", "Title", "Text to display in the upper label (Rich Text is supported!)"),
new Param("text2", "", "Artist", "Text to display in the lower label (Rich Text is supported!)"),
new Param("instantOn", false, "Instant Show", "Skip the show animation?"),
new Param("instantOff", false, "Instant Hide", "Skip the hide animation?"),
new Param("text1", "", "Title", "Set the text to display in the upper label. Rich text is supported."),
new Param("text2", "", "Artist", "Set the text to display in the lower label. Rich text is supported."),
new Param("instantOn", false, "Instant Show", "Toggle if the slide-in animation should be skipped."),
new Param("instantOff", false, "Instant Hide", "Toggle if the slide-out animation should be skipped."),
}
),
new GameAction("camera background color", "Camera Background Color", 1, true, new List<Param>()
{
new Param("color", Color.black, "Start Color", "Set the color at the start of the event."),
new Param("color2", Color.black, "End Color", "Set the color at the end of the event."),
new Param("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.")
}
),
@ -1008,20 +1020,20 @@ namespace HeavenStudio
resizable = true,
parameters = new()
{
new("intenStart", new EntityTypes.Float(0f, 1f), "Start Intensity"),
new("intenEnd", new EntityTypes.Float(0f, 1f, 1f), "End Intensity"),
new("intenStart", new EntityTypes.Float(0f, 1f), "Start Intensity", "Set the intensity at the start of the event."),
new("intenEnd", new EntityTypes.Float(0f, 1f, 1f), "End Intensity", "Set the intensity at the end of the event."),
new("colorStart", Color.black, "Start Color"),
new("colorEnd", Color.black, "End Color"),
new("colorStart", Color.black, "Start Color", "Set the color at the start of the event."),
new("colorEnd", Color.black, "End Color", "Set the color at the end of the event."),
new("smoothStart", new EntityTypes.Float(0.01f, 1f, 0.2f), "Start Smoothness"),
new("smoothEnd", new EntityTypes.Float(0.01f, 1f, 0.2f), "End Smoothness"),
new("smoothStart", new EntityTypes.Float(0.01f, 1f, 0.2f), "Start Smoothness", "Set the smoothness at the start of the event."),
new("smoothEnd", new EntityTypes.Float(0.01f, 1f, 0.2f), "End Smoothness", "Set the smoothness at the end of the event."),
new("roundStart", new EntityTypes.Float(0f, 1f, 1f), "Start Roundness"),
new("roundEnd", new EntityTypes.Float(0f, 1f, 1f), "End Roundness"),
new("rounded", false, "Rounded"),
new("roundStart", new EntityTypes.Float(0f, 1f, 1f), "Start Roundness", "Set the roundness at the start of the event."),
new("roundEnd", new EntityTypes.Float(0f, 1f, 1f), "End Roundness", "Set the roundness at the end of the event."),
new("rounded", false, "Rounded", "Toggle if the vignette should be equal on all sides."),
new("ease", Util.EasingFunction.Ease.Linear, "Ease", "", new()
new("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.", new()
{
new((x, y) => (Util.EasingFunction.Ease)x != Util.EasingFunction.Ease.Instant, new string[] { "intenStart", "colorStart", "smoothStart", "roundStart" })
}),
@ -1032,9 +1044,9 @@ namespace HeavenStudio
resizable = true,
parameters = new()
{
new("intenStart", new EntityTypes.Float(0f, 1f), "Start Intensity"),
new("intenEnd", new EntityTypes.Float(0f, 1f, 1f), "End Intensity"),
new("ease", Util.EasingFunction.Ease.Linear, "Ease", "", new()
new("intenStart", new EntityTypes.Float(0f, 1f), "Start Intensity", "Set the intensity at the start of the event."),
new("intenEnd", new EntityTypes.Float(0f, 1f, 1f), "End Intensity", "Set the intensity at the end of the event."),
new("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.", new()
{
new((x, y) => (Util.EasingFunction.Ease)x != Util.EasingFunction.Ease.Instant, new string[] { "intenStart" })
}),
@ -1045,22 +1057,22 @@ namespace HeavenStudio
resizable = true,
parameters = new()
{
new("intenStart", new EntityTypes.Float(0f, 100f, 0f), "Start Intensity"),
new("intenEnd", new EntityTypes.Float(0f, 100f, 1f), "End Intensity"),
new("intenStart", new EntityTypes.Float(0f, 100f, 0f), "Start Intensity", "Set the intensity at the start of the event."),
new("intenEnd", new EntityTypes.Float(0f, 100f, 1f), "End Intensity", "Set the intensity at the end of the event."),
new("colorStart", Color.white, "Start Tint"),
new("colorEnd", Color.white, "End Tint"),
new("colorStart", Color.white, "Start Tint", "Set the tint at the start of the event."),
new("colorEnd", Color.white, "End Tint", "Set the tint at the end of the event."),
new("thresholdStart", new EntityTypes.Float(0f, 100f, 1f), "Start Threshold"),
new("thresholdEnd", new EntityTypes.Float(0f, 100f, 1f), "End Threshold"),
new("thresholdStart", new EntityTypes.Float(0f, 100f, 1f), "Start Threshold", "Set the threshold at the start of the event."),
new("thresholdEnd", new EntityTypes.Float(0f, 100f, 1f), "End Threshold", "Set the threshold at the end of the event."),
new("softKneeStart", new EntityTypes.Float(0f, 1f, 0.5f), "Start Soft Knee"),
new("softKneeEnd", new EntityTypes.Float(0f, 1f, 0.5f), "End Soft Knee"),
new("softKneeStart", new EntityTypes.Float(0f, 1f, 0.5f), "Start Soft Knee", "Set the soft knee at the start of the event."),
new("softKneeEnd", new EntityTypes.Float(0f, 1f, 0.5f), "End Soft Knee", "Set the soft knee at the end of the event."),
new("anaStart", new EntityTypes.Float(-1f, 1f, 0f), "Start Anamorphic Ratio"),
new("anaEnd", new EntityTypes.Float(-1f, 1f, 0f), "End Anamorphic Ratio"),
new("anaStart", new EntityTypes.Float(-1f, 1f, 0f), "Start Anamorphic Ratio", "Set the anamorphic ratio at the start of the event."),
new("anaEnd", new EntityTypes.Float(-1f, 1f, 0f), "End Anamorphic Ratio", "Set the anamorphic ratio at the end of the event."),
new("ease", Util.EasingFunction.Ease.Linear, "Ease", "", new()
new("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.", new()
{
new((x, y) => (Util.EasingFunction.Ease)x != Util.EasingFunction.Ease.Instant, new string[] { "intenStart", "colorStart", "thresholdStart", "softKneeStart", "anaStart" })
}),
@ -1071,15 +1083,15 @@ namespace HeavenStudio
resizable = true,
parameters = new()
{
new("intenStart", new EntityTypes.Float(-100f, 100f, 0f), "Start Intensity"),
new("intenEnd", new EntityTypes.Float(-100f, 100f, 1f), "End Intensity"),
new("intenStart", new EntityTypes.Float(-100f, 100f, 0f), "Start Intensity", "Set the intensity at the start of the event."),
new("intenEnd", new EntityTypes.Float(-100f, 100f, 1f), "End Intensity", "Set the intensity at the end of the event."),
new("xStart", new EntityTypes.Float(0f, 1f, 1f), "Start X Multiplier"),
new("yStart", new EntityTypes.Float(0f, 1f, 1f), "Start Y Multiplier"),
new("xEnd", new EntityTypes.Float(0f, 1f, 1f), "End X Multiplier"),
new("yEnd", new EntityTypes.Float(0f, 1f, 1f), "End Y Multiplier"),
new("xStart", new EntityTypes.Float(0f, 1f, 1f), "Start X Multiplier", "Set the X multiplier at the start of the event."),
new("xEnd", new EntityTypes.Float(0f, 1f, 1f), "End X Multiplier", "Set the X multiplier at the end of the event."),
new("yStart", new EntityTypes.Float(0f, 1f, 1f), "Start Y Multiplier", "Set the Y multiplier at the start of the event."),
new("yEnd", new EntityTypes.Float(0f, 1f, 1f), "End Y Multiplier", "Set the Y multiplier at the end of the event."),
new("ease", Util.EasingFunction.Ease.Linear, "Ease", "", new()
new("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.", new()
{
new((x, y) => (Util.EasingFunction.Ease)x != Util.EasingFunction.Ease.Instant, new string[] { "intenStart", "xStart", "yStart" })
}),
@ -1090,15 +1102,15 @@ namespace HeavenStudio
resizable = true,
parameters = new()
{
new("intenStart", new EntityTypes.Float(0f, 1f), "Start Intensity"),
new("intenEnd", new EntityTypes.Float(0f, 1f, 1f), "End Intensity"),
new("intenStart", new EntityTypes.Float(0f, 1f), "Start Intensity", "Set the intensity at the start of the event."),
new("intenEnd", new EntityTypes.Float(0f, 1f, 1f), "End Intensity", "Set the intensity at the end of the event."),
new("sizeStart", new EntityTypes.Float(0.3f, 3f, 1f), "Start Size"),
new("sizeEnd", new EntityTypes.Float(0.3f, 3f, 1f), "End Size"),
new("sizeStart", new EntityTypes.Float(0.3f, 3f, 1f), "Start Size", "Set the size at the start of the event."),
new("sizeEnd", new EntityTypes.Float(0.3f, 3f, 1f), "End Size", "Set the size at the end of the event."),
new("colored", true, "Colored"),
new("colored", true, "Colored", "Toggle if the grain will be colored."),
new("ease", Util.EasingFunction.Ease.Linear, "Ease", "", new()
new("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.", new()
{
new((x, y) => (Util.EasingFunction.Ease)x != Util.EasingFunction.Ease.Instant, new string[] { "intenStart", "sizeStart" })
}),
@ -1109,52 +1121,44 @@ namespace HeavenStudio
resizable = true,
parameters = new()
{
new("tempStart", new EntityTypes.Float(-100f, 100f), "Start Temperature"),
new("tempEnd", new EntityTypes.Float(-100f, 100f), "End Temperature"),
new("tempStart", new EntityTypes.Float(-100f, 100f), "Start Temperature", "Set the temperature at the start of the event."),
new("tempEnd", new EntityTypes.Float(-100f, 100f), "End Temperature", "Set the temperature at the end of the event."),
new("tintStart", new EntityTypes.Float(-100f, 100f), "Start Tint"),
new("tintEnd", new EntityTypes.Float(-100f, 100f), "End Tint"),
new("tintStart", new EntityTypes.Float(-100f, 100f), "Start Tint", "Set the tint at the start of the event."),
new("tintEnd", new EntityTypes.Float(-100f, 100f), "End Tint", "Set the tint at the end of the event."),
new("colorStart", Color.white, "Start Color Filter"),
new("colorEnd", Color.white, "End Color Filter"),
new("colorStart", Color.white, "Start Color Filter", "Set the color filter at the start of the event."),
new("colorEnd", Color.white, "End Color Filter", "Set the color filter at the end of the event."),
new("hueShiftStart", new EntityTypes.Float(-180f, 180f), "Start Hue Shift"),
new("hueShiftEnd", new EntityTypes.Float(-180f, 180f), "End Hue Shift"),
new("hueShiftStart", new EntityTypes.Float(-180f, 180f), "Start Hue Shift", "Set the hue shift at the start of the event."),
new("hueShiftEnd", new EntityTypes.Float(-180f, 180f), "End Hue Shift", "Set the hue shift at the end of the event."),
new("satStart", new EntityTypes.Float(-100f, 100f), "Start Saturation"),
new("satEnd", new EntityTypes.Float(-100f, 100f), "End Saturation"),
new("satStart", new EntityTypes.Float(-100f, 100f), "Start Saturation", "Set the saturation at the start of the event."),
new("satEnd", new EntityTypes.Float(-100f, 100f), "End Saturation", "Set the saturation at the end of the event."),
new("brightStart", new EntityTypes.Float(-100f, 100f), "Start Brightness"),
new("brightEnd", new EntityTypes.Float(-100f, 100f), "End Brightness"),
new("brightStart", new EntityTypes.Float(-100f, 100f), "Start Brightness", "Set the brightness at the start of the event."),
new("brightEnd", new EntityTypes.Float(-100f, 100f), "End Brightness", "Set the brightness at the end of the event."),
new("conStart", new EntityTypes.Float(-100f, 100f), "Start Contrast"),
new("conEnd", new EntityTypes.Float(-100f, 100f), "End Contrast"),
new("conStart", new EntityTypes.Float(-100f, 100f), "Start Contrast", "Set the contrast at the start of the event."),
new("conEnd", new EntityTypes.Float(-100f, 100f), "End Contrast", "Set the contrast at the end of the event."),
new("ease", Util.EasingFunction.Ease.Linear, "Ease", "", new()
new("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.", new()
{
new((x, y) => (Util.EasingFunction.Ease)x != Util.EasingFunction.Ease.Instant, new string[] { "tempStart", "tintStart", "colorStart", "hueShiftStart", "satStart", "brightStart", "conStart" })
}),
}
},
new GameAction("fitScreen", "Fit Game To Screen")
{
defaultLength = 0.5f,
parameters = new()
{
new("enable", true, "Enabled")
}
},
new GameAction("screenTiling", "Tile Screen")
{
resizable = true,
parameters = new()
{
new("xStart", new EntityTypes.Float(1, 100, 1), "Start Horizontal Tiles"),
new("yStart", new EntityTypes.Float(1, 100, 1), "Start Vertical Tiles"),
new("xEnd", new EntityTypes.Float(1, 100, 1), "End Horizontal Tiles"),
new("yEnd", new EntityTypes.Float(1, 100, 1), "End Vertical Tiles"),
new Param("axis", StaticCamera.ViewAxis.All, "Axis"),
new("ease", Util.EasingFunction.Ease.Linear, "Ease", "", new()
new("xStart", new EntityTypes.Float(1, 100, 1), "Start Horizontal Tiles", "Set the amount of horizontal tiles at the start of the event."),
new("xEnd", new EntityTypes.Float(1, 100, 1), "End Horizontal Tiles", "Set the amount of horizontal tiles at the end of the event."),
new("yStart", new EntityTypes.Float(1, 100, 1), "Start Vertical Tiles", "Set the amount of vertical tiles at the start of the event."),
new("yEnd", new EntityTypes.Float(1, 100, 1), "End Vertical Tiles", "Set the amount of vertical tiles at the end of the event."),
new Param("axis", StaticCamera.ViewAxis.All, "Axis", "Set if only a specific axis should be modified."),
new("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.", new()
{
new((x, y) => (Util.EasingFunction.Ease)x != Util.EasingFunction.Ease.Instant, new string[] { "xStart", "yStart" })
}),
@ -1165,12 +1169,12 @@ namespace HeavenStudio
resizable = true,
parameters = new()
{
new("xScrollStart", new EntityTypes.Float(-100, 100, 0), "Start Horizontal Scroll"),
new("yScrollStart", new EntityTypes.Float(-100, 100, 0), "Start Vertical Scroll"),
new("xScrollEnd", new EntityTypes.Float(-100, 100, 0), "End Horizontal Scroll"),
new("yScrollEnd", new EntityTypes.Float(-100, 100, 0), "End Vertical Scroll"),
new Param("axis", StaticCamera.ViewAxis.All, "Axis"),
new("ease", Util.EasingFunction.Ease.Linear, "Ease", "", new()
new("xScrollStart", new EntityTypes.Float(-100, 100, 0), "Start Horizontal Scroll", "Set the horizontal scroll at the start of the event."),
new("xScrollEnd", new EntityTypes.Float(-100, 100, 0), "End Horizontal Scroll", "Set the horizontal scroll at the end of the event."),
new("yScrollStart", new EntityTypes.Float(-100, 100, 0), "Start Vertical Scroll", "Set the vertical scroll at the start of the event."),
new("yScrollEnd", new EntityTypes.Float(-100, 100, 0), "End Vertical Scroll", "Set the vertical scroll at the end of the event."),
new Param("axis", StaticCamera.ViewAxis.All, "Axis", "Set if only a specific axis should be modified."),
new("ease", Util.EasingFunction.Ease.Linear, "Ease", "Set the easing of the action.", new()
{
new((x, y) => (Util.EasingFunction.Ease)x != Util.EasingFunction.Ease.Instant, new string[] { "xScrollStart", "yScrollStart" })
}),

2
Assets/Scripts/UI/SettingsDialog/Tabs/CreditsLegalSettings.cs
View file

@ -27,7 +27,6 @@ namespace HeavenStudio.Editor
public void OnClickCountUp()
{
SecretCounter++;
Debug.Log("SecretCounter: " + SecretCounter);
if (SecretCounter == 10 && Editor.instance != null)
{
secretObject.SetActive(true);
@ -40,7 +39,6 @@ namespace HeavenStudio.Editor
SecretActive = true;
SoundByte.PlayOneShot("applause");
Debug.Log("Activating Studio Dance...");
if (Editor.instance == null)
{

4
Assets/Scripts/Util/BeatAction.cs
View file

@ -26,8 +26,8 @@ namespace HeavenStudio.Util
{
if (behaviour == null)
{
Debug.LogWarning("Starting a BeatAction with no assigned behaviour. The Conductor will be used instead.");
behaviour = Conductor.instance;
Debug.LogWarning("Starting a BeatAction with no assigned behaviour. The Game Manager will be used instead.");
behaviour = GameManager.instance;
}
CancellationTokenSource cancelToken = new CancellationTokenSource();
RunAsync(behaviour, actions, cancelToken.Token).Forget();