etc/HeavenStudioPlus
0
0
Fork 0
mirror of https://github.com/RHeavenStudioPlus/HeavenStudioPlus.git synced 2024-11-27 03:53:01 +00:00
Code Issues Projects Releases Packages Wiki Activity

start reorganize GameAction

Browse source 
- this won't compile, haven't finished yet
This commit is contained in:
minenice55 2022-08-20 19:03:51 -04:00
parent 4e4dc0f7b6
commit e2631acd2b
11 changed files with 730 additions and 362 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

49
Assets/Scripts/BeatmapFormats/DynamicBeatmap.cs
View file

@ -19,9 +19,48 @@ namespace HeavenStudio
public Dictionary<string, object> properties = public Dictionary<string, object> properties =
new Dictionary<string, object>() { new Dictionary<string, object>() {
{"remixtitle", "New Remix"}, // software version (MajorMinorPatch, revision)
{"remixauthor", "Your Name"}, {"productversion", 000},
{"productsubversion", 0},
// general chart info
{"remixtitle", "New Remix"}, // chart name
{"remixauthor", "Your Name"}, // charter's name
{"remixlevel", 1}, // chart difficulty
{"remixtempo", 120f}, // avg. chart tempo
{"remixtags", ""}, // chart tags
{"icontype", 0}, // chart icon (presets, custom - future)
{"iconurl", ""}, // custom icon location (future)
// chart song info
{"idolgenre", "Song Genre"}, // song genre
{"idolsong", "Song Name"}, // song name
{"idolcredit", "Artist"}, // song artist
// chart prologue
{"prologuetype", 0}, // prologue card animation (future)
{"prologuecaption", "Remix"}, // prologue card sub-title (future)
// chart results screen messages
{"resultcaption", "Rhythm League Notes"}, // result screen header
{"resultcommon_hi", "Good rhythm."}, // generic "Superb" message (one-liner, or second line for single-type)
{"resultcommon_ok", "Eh. Passable."}, // generic "OK" message (one-liner, or second line for single-type)
{"resultcommon_ng", "Try harder next time."}, // generic "Try Again" message (one-liner, or second line for single-type)
// the following are shown / hidden in-editor depending on the tags of the games used
{"resultnormal_hi", "You show strong fundamentals."}, // "Superb" message for normal games (two-liner)
{"resultnormal_ng", "Work on your fundamentals."}, // "Try Again" message for normal games (two-liner)
{"resultkeep_hi", "You kept the beat well."}, // "Superb" message for keep-the-beat games (two-liner)
{"resultkeep_ng", "You had trouble keeping the beat."}, // "Try Again" message for keep-the-beat games (two-liner)
{"resultaim_hi", "You had great aim."}, // "Superb" message for aim games (two-liner)
{"resultaim_ng", "Your aim was a little shaky."}, // "Try Again" message for aim games (two-liner)
{"resultrepeat_hi", "You followed the example well."}, // "Superb" message for call-and-response games (two-liner)
{"resultrepeat_ng", "Next time, follow the example better."}, // "Try Again" message for call-and-response games (two-liner)
}; };
public List<DynamicEntity> entities = new List<DynamicEntity>(); public List<DynamicEntity> entities = new List<DynamicEntity>();
public List<TempoChange> tempoChanges = new List<TempoChange>(); public List<TempoChange> tempoChanges = new List<TempoChange>();
public List<VolumeChange> volumeChanges = new List<VolumeChange>(); public List<VolumeChange> volumeChanges = new List<VolumeChange>();
@ -68,6 +107,12 @@ namespace HeavenStudio
} }
} }
} }
public void CreateProperty(string name, object defaultValue)
{
if (!DynamicData.ContainsKey(name))
DynamicData.Add(name, defaultValue);
}
} }
[Serializable] [Serializable]

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

@ -12,39 +12,65 @@ namespace HeavenStudio.Games.Loaders
public static Minigame AddGame(EventCaller eventCaller) { public static Minigame AddGame(EventCaller eventCaller) {
return new Minigame("djSchool", "DJ School", "008c97", false, false, new List<GameAction>() return new Minigame("djSchool", "DJ School", "008c97", false, false, new List<GameAction>()
{ {
//new GameAction("bop", delegate { DJSchool.instance.Bop(eventCaller.currentEntity.beat, eventCaller.currentEntity.length); }, 0.5f, true), new GameAction("bop", "Bop")
new GameAction("bop", delegate { DJSchool.instance.Bop(eventCaller.currentEntity.toggle); }, 0.5f, false, new List<Param>()
{ {
new Param("toggle", true, "Bop", "Whether both will bop to the beat or not") function = delegate { DJSchool.instance.Bop(eventCaller.currentEntity.toggle); },
}), defaultLength = 0.5f,
new GameAction("and stop ooh", delegate { var e = eventCaller.currentEntity; DJSchool.instance.AndStop(e.beat, e.toggle); }, 2.5f, false, parameters = new List<Param>()
inactiveFunction: delegate { var e = eventCaller.currentEntity; DJSchool.WarnAndStop(e.beat, e.toggle); }, {
parameters: new List<Param>() new Param("toggle", true, "Bop", "Whether both will bop to the beat or not")
}
},
new GameAction("and stop ooh", "And Stop!")
{ {
new Param("toggle", true, "Ooh", "Whether or not the \"ooh\" sound should be played") function = delegate { var e = eventCaller.currentEntity; DJSchool.instance.AndStop(e.beat, e.toggle); },
}), defaultLength = 2.5f,
new GameAction("break c'mon ooh", delegate { var e = eventCaller.currentEntity; DJSchool.instance.BreakCmon(e.beat, e.type, e.toggle); }, 3f, false, inactiveFunction = delegate { var e = eventCaller.currentEntity; DJSchool.WarnAndStop(e.beat, e.toggle); },
inactiveFunction: delegate { var e = eventCaller.currentEntity; DJSchool.WarnBreakCmon(e.beat, e.type, e.toggle); }, parameters = new List<Param>()
parameters: new List<Param>() {
new Param("toggle", true, "Ooh", "Whether or not the \"ooh\" sound should be played")
}
},
new GameAction("break c'mon ooh", "Break, C'mon!")
{ {
new Param("type", DJSchool.DJVoice.Standard, "Voice", "The voice line to play"), function = delegate { var e = eventCaller.currentEntity; DJSchool.instance.BreakCmon(e.beat, e.type, e.toggle); },
new Param("toggle", true, "Ooh", "Whether or not the \"ooh\" sound should be played") defaultLength = 3f,
}), inactiveFunction = delegate { var e = eventCaller.currentEntity; DJSchool.WarnBreakCmon(e.beat, e.type, e.toggle); },
new GameAction("scratch-o hey", delegate { DJSchool.instance.ScratchoHey(eventCaller.currentEntity.beat, eventCaller.currentEntity.type, eventCaller.currentEntity.toggle); }, 3f, false, new List<Param>() 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 GameAction("scratch-o hey", "Scratch-o")
{ {
new Param("type", DJSchool.DJVoice.Standard, "Voice", "The voice line to play"), function = delegate { DJSchool.instance.ScratchoHey(eventCaller.currentEntity.beat, eventCaller.currentEntity.type, eventCaller.currentEntity.toggle); },
new Param("toggle", false, "Fast Hey", "Activate Remix 4 (DS) beat") defaultLength = 3f,
}), parameters = new List<Param>()
new GameAction("dj voice lines", delegate { DJSchool.instance.voiceLines(eventCaller.currentEntity.beat, eventCaller.currentEntity.type); }, 2f, false, {
inactiveFunction: delegate { DJSchool.WarnDJVoiceLines(eventCaller.currentEntity.beat, eventCaller.currentEntity.type); }, new Param("type", DJSchool.DJVoice.Standard, "Voice", "The voice line to play"),
parameters: new List<Param>() new Param("toggle", false, "Fast Hey", "Activate Remix 4 (DS) beat")
}
},
new GameAction("dj voice lines", "DJ Yellow Banter")
{ {
new Param("type", DJSchool.DJVoiceLines.CheckItOut, "Voice Lines", "The voice line to play"), function = delegate { DJSchool.instance.voiceLines(eventCaller.currentEntity.beat, eventCaller.currentEntity.type); },
}), defaultLength = 2f,
new GameAction("sound FX", delegate { DJSchool.instance.soundFX(eventCaller.currentEntity.toggle); }, .5f, false, new List<Param>() inactiveFunction = delegate { DJSchool.WarnDJVoiceLines(eventCaller.currentEntity.beat, eventCaller.currentEntity.type); },
parameters = new List<Param>()
{
new Param("type", DJSchool.DJVoiceLines.CheckItOut, "Voice Lines", "The voice line to play"),
}
},
new GameAction("sound FX", "Scratchy Music")
{ {
new Param("toggle", false, "Radio FX", "Toggle on and off for Radio Effects") function = delegate { DJSchool.instance.soundFX(eventCaller.currentEntity.toggle); },
}) defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("toggle", false, "Radio FX", "Toggle on and off for Radio Effects")
}
}
}, },
new List<string>() {"ntr", "normal"}, new List<string>() {"ntr", "normal"},
"ntrdj", "en", "ntrdj", "en",

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

@ -13,49 +13,76 @@ namespace HeavenStudio.Games.Loaders
public static Minigame AddGame(EventCaller eventCaller) { public static Minigame AddGame(EventCaller eventCaller) {
return new Minigame("fanClub", "Fan Club", "FDFD00", false, false, new List<GameAction>() return new Minigame("fanClub", "Fan Club", "FDFD00", false, false, new List<GameAction>()
{ {
new GameAction("bop", delegate { var e = eventCaller.currentEntity; FanClub.instance.Bop(e.beat, e.length, e.type); }, 0.5f, true, parameters: new List<Param>() new GameAction("bop", "Bop")
{ {
new Param("type", FanClub.IdolBopType.Both, "Bop target", "Who to make bop"), function = delegate { var e = eventCaller.currentEntity; FanClub.instance.Bop(e.beat, e.length, e.type); },
}), defaultLength = 0.5f,
resizable = true,
new GameAction("yeah, yeah, yeah", delegate { var e = eventCaller.currentEntity; FanClub.instance.CallHai(e.beat, e.toggle); }, 8, false, parameters: new List<Param>() parameters = new List<Param>()
{
new Param("type", FanClub.IdolBopType.Both, "Bop target", "Who to make bop"),
}
},
new GameAction("yeah, yeah, yeah", "Yeah, Yeah, Yeah!")
{
function = delegate { var e = eventCaller.currentEntity; FanClub.instance.CallHai(e.beat, e.toggle); },
defaultLength = 8,
parameters = new List<Param>()
{ {
new Param("toggle", false, "Disable call", "Disable the idol's call") new Param("toggle", false, "Disable call", "Disable the idol's call")
}, },
inactiveFunction: delegate { var e = eventCaller.currentEntity; FanClub.WarnHai(e.beat, e.toggle);} inactiveFunction = delegate { var e = eventCaller.currentEntity; FanClub.WarnHai(e.beat, e.toggle);}
), },
new GameAction("I suppose", "I Suppose!")
new GameAction("I suppose", delegate { var e = eventCaller.currentEntity; FanClub.instance.CallKamone(e.beat, e.toggle, 0, e.type); }, 6, false, parameters: new List<Param>() {
function = delegate { var e = eventCaller.currentEntity; FanClub.instance.CallKamone(e.beat, e.toggle, 0, e.type); },
defaultLength = 6,
parameters = new List<Param>()
{ {
new Param("type", FanClub.KamoneResponseType.Through, "Response type", "Type of response to use"), 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("toggle", false, "Disable call", "Disable the idol's call")
}, },
inactiveFunction: delegate { var e = eventCaller.currentEntity; FanClub.WarnKamone(e.beat, e.toggle, 0, e.type);} inactiveFunction = delegate { var e = eventCaller.currentEntity; FanClub.WarnKamone(e.beat, e.toggle, 0, e.type);}
), },
new GameAction("double clap", "Double Clap")
new GameAction("double clap", delegate { var e = eventCaller.currentEntity; FanClub.instance.CallBigReady(e.beat, e.toggle); }, 4, false, parameters: new List<Param>() {
function = delegate { var e = eventCaller.currentEntity; FanClub.instance.CallBigReady(e.beat, e.toggle); },
defaultLength = 4,
parameters = new List<Param>()
{ {
new Param("toggle", false, "Disable call", "Disable the call") new Param("toggle", false, "Disable call", "Disable the call")
}, },
inactiveFunction: delegate { var e = eventCaller.currentEntity; FanClub.WarnBigReady(e.beat, e.toggle); } inactiveFunction = delegate { var e = eventCaller.currentEntity; FanClub.WarnBigReady(e.beat, e.toggle); }
), },
new GameAction("play idol animation", "Idol Coreography")
new GameAction("play idol animation", delegate { var e = eventCaller.currentEntity; FanClub.instance.PlayAnim(e.beat, e.length, e.type); }, 1, true, parameters: new List<Param>()
{ {
new Param("type", FanClub.IdolAnimations.Bop, "Animation", "Animation to play") function = delegate { var e = eventCaller.currentEntity; FanClub.instance.PlayAnim(e.beat, e.length, e.type); },
}), resizable = true,
parameters = new List<Param>()
new GameAction("play stage animation", delegate { var e = eventCaller.currentEntity; FanClub.instance.PlayAnimStage(e.beat, e.type); }, 1, true, parameters: new List<Param>() {
new Param("type", FanClub.IdolAnimations.Bop, "Animation", "Animation to play")
}
},
new GameAction("play stage animation", "Stage Coreography")
{
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 GameAction("set performance type", "Coreography Type")
{ {
new Param("type", FanClub.StageAnimations.Flash, "Animation", "Animation to play")
}),
new GameAction("set performance type", delegate { var e = eventCaller.currentEntity; FanClub.SetPerformanceType(e.type);}, 0.5f, false, parameters: new List<Param>() function = delegate { var e = eventCaller.currentEntity; FanClub.SetPerformanceType(e.type);},
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 of animations for the idol to use")
}, },
inactiveFunction: delegate { var e = eventCaller.currentEntity; FanClub.SetPerformanceType(e.type); } inactiveFunction = delegate { var e = eventCaller.currentEntity; FanClub.SetPerformanceType(e.type); }
), },
}, },
new List<string>() {"ntr", "normal"}, new List<string>() {"ntr", "normal"},
"ntridol", "jp", "ntridol", "jp",

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

@ -13,58 +13,97 @@ namespace HeavenStudio.Games.Loaders
public static Minigame AddGame(EventCaller eventCaller) { public static Minigame AddGame(EventCaller eventCaller) {
return new Minigame("karateman", "Karate Man", "70A8D8", false, false, new List<GameAction>() return new Minigame("karateman", "Karate Man", "70A8D8", false, false, new List<GameAction>()
{ {
new GameAction("bop", delegate { KarateMan.instance.ToggleBop(eventCaller.currentEntity.toggle); }, 0.5f, false, new List<Param>() new GameAction("bop", "Bop")
{
function = delegate { KarateMan.instance.ToggleBop(eventCaller.currentEntity.toggle); },
defaultLength = 0.5f,
parameters = new List<Param>()
{ {
new Param("toggle", true, "Bop", "Whether to bop to the beat or not") new Param("toggle", true, "Bop", "Whether to bop to the beat or not")
}, },
inactiveFunction: delegate { KarateMan.ToggleBopUnloaded(eventCaller.currentEntity.toggle); } inactiveFunction = delegate { KarateMan.ToggleBopUnloaded(eventCaller.currentEntity.toggle); }
), },
new GameAction("hit", delegate { var e = eventCaller.currentEntity; KarateMan.instance.CreateItem(e.beat, e.type, e.type2); }, 2, false, new GameAction("hit", "Toss Object") {
new List<Param>() function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.CreateItem(e.beat, e.type, e.type2); },
defaultLength = 2,
parameters = new List<Param>()
{ {
new Param("type", KarateMan.HitType.Pot, "Object", "The object to fire"), 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("type2", KarateMan.KarateManFaces.Normal, "Success Expression", "The facial expression to set Joe to on hit")
}), }
new GameAction("bulb", delegate { var e = eventCaller.currentEntity; KarateMan.instance.CreateBulbSpecial(e.beat, e.type, e.colorA, e.type2); }, 2, false, },
new List<Param>() new GameAction("bulb", "Toss Lightbulb")
{
function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.CreateBulbSpecial(e.beat, e.type, e.colorA, e.type2); },
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 Param("type", KarateMan.LightBulbType.Normal, "Type", "The preset bulb type. Yellow is used for kicks while Blue is used for combos"),
new Param("colorA", new Color(1f,1f,1f), "Custom Color", "The color to use when the bulb type is set to Custom"), 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("type2", KarateMan.KarateManFaces.Normal, "Success Expression", "The facial expression to set Joe to on hit")
}), },
new GameAction("kick", delegate { var e = eventCaller.currentEntity; KarateMan.instance.Kick(e.beat, e.toggle, e.type); }, 4f, false, },
new List<Param>() new GameAction("kick", "Special: Kick")
{
function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.Kick(e.beat, e.toggle, e.type); },
defaultLength = 4f,
parameters = new List<Param>()
{ {
new Param("toggle", false, "Contains Ball", "Barrel contains a ball instead of a bomb?"), new Param("toggle", false, "Contains Ball", "Barrel contains a ball instead of a bomb?"),
new Param("type", KarateMan.KarateManFaces.Smirk, "Success Expression", "The facial expression to set Joe to on hit") new Param("type", KarateMan.KarateManFaces.Smirk, "Success Expression", "The facial expression to set Joe to on hit")
} }
), },
new GameAction("combo", delegate { var e = eventCaller.currentEntity; KarateMan.instance.Combo(e.beat, e.type); }, 4f, false, new GameAction("combo", "Special: Combo")
new List<Param>() {
function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.Combo(e.beat, e.type); },
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("type", KarateMan.KarateManFaces.Happy, "Success Expression", "The facial expression to set Joe to on hit")
} }
), },
new GameAction("hitX", delegate { var e = eventCaller.currentEntity; KarateMan.instance.DoWord(e.beat, e.type); }, 1f, false, new GameAction("hitX", "Warnings")
new List<Param>() {
function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.DoWord(e.beat, e.type); },
defaultLength = 1f,
parameters = new List<Param>()
{ {
new Param("type", KarateMan.HitThree.HitThree, "Type", "The warning text to show") new Param("type", KarateMan.HitThree.HitThree, "Type", "The warning text to show")
}, },
inactiveFunction: delegate { var e = eventCaller.currentEntity; KarateMan.DoWordSound(e.beat, e.type); } inactiveFunction = delegate { var e = eventCaller.currentEntity; KarateMan.DoWordSound(e.beat, e.type); }
), },
new GameAction("special camera", delegate { var e = eventCaller.currentEntity; KarateMan.DoSpecialCamera(e.beat, e.length, e.toggle); }, 8f, true, new List<Param>() new GameAction("special camera", "Special Camera")
{
function = delegate { var e = eventCaller.currentEntity; KarateMan.DoSpecialCamera(e.beat, e.length, e.toggle); },
defaultLength = 8f,
resizable = true,
parameters = new List<Param>()
{ {
new Param("toggle", true, "Return Camera", "Camera zooms back in?"), new Param("toggle", true, "Return Camera", "Camera zooms back in?"),
}, },
inactiveFunction: delegate { var e = eventCaller.currentEntity; KarateMan.DoSpecialCamera(e.beat, e.length, e.toggle); } inactiveFunction = delegate { var e = eventCaller.currentEntity; KarateMan.DoSpecialCamera(e.beat, e.length, e.toggle); }
), },
new GameAction("prepare", delegate { var e = eventCaller.currentEntity; KarateMan.instance.Prepare(e.beat, e.length);}, 1f, true), new GameAction("prepare", "Preparation Stance")
new GameAction("set gameplay modifiers", delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetGameplayMods(e.beat, e.type, e.toggle); }, 0.5f, false, new List<Param>()
{ {
new Param("type", KarateMan.NoriMode.None, "Flow Bar type", "The type of Flow bar to use"), function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.Prepare(e.beat, e.length);},
new Param("toggle", true, "Enable Combos", "Allow the player to combo? (Contextual combos will still be allowed even when off)"), resizable = true
}), },
new GameAction("set background effects", delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetBgAndShadowCol(e.beat, e.length, e.type, e.type2, e.colorA, e.colorB, e.type3); KarateMan.instance.SetBgTexture(e.type4, e.type5, e.colorC, e.colorD); }, 0.5f, true, new List<Param>() new GameAction("set gameplay modifiers", "Gameplay Modifiers")
{
function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetGameplayMods(e.beat, e.type, e.toggle); },
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("type", KarateMan.NoriMode.None, "Flow Bar type", "The type of Flow bar to use"),
new Param("toggle", true, "Enable Combos", "Allow the player to combo? (Contextual combos will still be allowed even when off)"),
}
},
new GameAction("set background effects", "Background Appearance")
{
function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetBgAndShadowCol(e.beat, e.length, e.type, e.type2, e.colorA, e.colorB, e.type3); KarateMan.instance.SetBgTexture(e.type4, e.type5, e.colorC, e.colorD); },
defaultLength = 0.5f,
resizable = true,
parameters = new List<Param>()
{ {
new Param("type", KarateMan.BackgroundType.Yellow, "Background Type", "The preset background type"), new Param("type", KarateMan.BackgroundType.Yellow, "Background Type", "The preset background type"),
new Param("type2", KarateMan.ShadowType.Tinted, "Shadow Type", "The shadow type. If Tinted doesn't work with your background color try Custom"), new Param("type2", KarateMan.ShadowType.Tinted, "Shadow Type", "The shadow type. If Tinted doesn't work with your background color try Custom"),
@ -77,43 +116,96 @@ 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 Param("colorD", new Color(), "Fading Filter Color", "When using the Fade background effect, make filter colour fade to this colour"),
}, },
inactiveFunction: delegate { var e = eventCaller.currentEntity; KarateMan.SetBgEffectsUnloaded(e.beat, e.length, e.type, e.type2, e.colorA, e.colorB, e.type3, e.type4, e.type5, e.colorC, e.colorD); } inactiveFunction = delegate { var e = eventCaller.currentEntity; KarateMan.SetBgEffectsUnloaded(e.beat, e.length, e.type, e.type2, e.colorA, e.colorB, e.type3, e.type4, e.type5, e.colorC, e.colorD); }
), },
new GameAction("set object colors", delegate { var e = eventCaller.currentEntity; KarateMan.UpdateMaterialColour(e.colorA, e.colorB, e.colorC); }, 0.5f, false, new List<Param>() new GameAction("set object colors", "Object Colors")
{
function = delegate { var e = eventCaller.currentEntity; KarateMan.UpdateMaterialColour(e.colorA, e.colorB, e.colorC); },
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("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("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("colorC", new Color(1,1,1,1), "Item Color", "The color to use for the thrown items"),
}, },
inactiveFunction: delegate { var e = eventCaller.currentEntity; KarateMan.UpdateMaterialColour(e.colorA, e.colorB, e.colorC); } inactiveFunction = delegate { var e = eventCaller.currentEntity; KarateMan.UpdateMaterialColour(e.colorA, e.colorB, e.colorC); }
), },
new GameAction("particle effects", delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetParticleEffect(e.beat, e.type, e.valA, e.valB); }, 0.5f, false, new List<Param>() new GameAction("particle effects", "Particle Effects")
{ {
new Param("type", KarateMan.ParticleType.None, "Particle Type", "The type of particle effect to spawn. Using \"None\" will stop all effects"), function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetParticleEffect(e.beat, e.type, e.valA, e.valB); },
new Param("valA", new EntityTypes.Float(0f, 64f, 1f), "Wind Strength", "The strength of the particle wind"), defaultLength = 0.5f,
new Param("valB", new EntityTypes.Float(1f, 16f, 1f), "Particle Intensity", "The intensity of the particle effect") parameters = new List<Param>()
}), {
new GameAction("force facial expression", delegate { KarateMan.instance.SetFaceExpression(eventCaller.currentEntity.type); }, 0.5f, false, 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("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 GameAction("force facial expression", "Set Facial Expression")
{ {
new Param("type", KarateMan.KarateManFaces.Normal, "Facial Expression", "The facial expression to force Joe to. Special moves may override this") function = delegate { KarateMan.instance.SetFaceExpression(eventCaller.currentEntity.type); },
}), defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("type", KarateMan.KarateManFaces.Normal, "Facial Expression", "The facial expression to force Joe to. Special moves may override this")
}
},
// These are still here for backwards-compatibility but are hidden in the editor // These are still here for backwards-compatibility but are hidden in the editor
new GameAction("pot", delegate { KarateMan.instance.CreateItem(eventCaller.currentEntity.beat, 0, (int) KarateMan.HitType.Pot); }, 2, hidden: true), new GameAction("pot", "")
new GameAction("rock", delegate { KarateMan.instance.CreateItem(eventCaller.currentEntity.beat, 0, (int) KarateMan.HitType.Rock); }, 2, hidden: true), {
new GameAction("ball", delegate { KarateMan.instance.CreateItem(eventCaller.currentEntity.beat, 0, (int) KarateMan.HitType.Ball); }, 2, hidden: true), function = delegate { KarateMan.instance.CreateItem(eventCaller.currentEntity.beat, 0, (int) KarateMan.HitType.Pot); },
new GameAction("tacobell", delegate { KarateMan.instance.CreateItem(eventCaller.currentEntity.beat, 0, (int) KarateMan.HitType.TacoBell); }, 2, hidden: true), defaultLength = 2,
new GameAction("hit4", delegate { KarateMan.instance.DoWord(eventCaller.currentEntity.beat, (int) KarateMan.HitThree.HitFour); }, hidden: true), hidden = true
new GameAction("bgfxon", delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetBgFx((int) KarateMan.BackgroundFXType.Sunburst, e.beat, e.length); }, hidden: true), },
new GameAction("bgfxoff", delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetBgFx((int) KarateMan.BackgroundFXType.None, e.beat, e.length); }, hidden: true), new GameAction("rock", "")
new GameAction("hit3", delegate { var e = eventCaller.currentEntity; KarateMan.instance.DoWord(e.beat, e.type); }, 1f, false, {
new List<Param>() function = delegate { KarateMan.instance.CreateItem(eventCaller.currentEntity.beat, 0, (int) KarateMan.HitType.Rock); },
defaultLength = 2,
hidden = true
},
new GameAction("ball", "")
{
function = delegate { KarateMan.instance.CreateItem(eventCaller.currentEntity.beat, 0, (int) KarateMan.HitType.Ball); },
defaultLength = 2,
hidden = true
},
new GameAction("tacobell", "")
{
function = delegate { KarateMan.instance.CreateItem(eventCaller.currentEntity.beat, 0, (int) KarateMan.HitType.TacoBell); },
defaultLength = 2,
hidden = true
},
new GameAction("bgfxon", "")
{
function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetBgFx((int) KarateMan.BackgroundFXType.Sunburst, e.beat, e.length); },
hidden = true
},
new GameAction("bgfxoff", "")
{
function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetBgFx((int) KarateMan.BackgroundFXType.None, e.beat, e.length); },
hidden = true
},
new GameAction("hit3", "")
{
function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.DoWord(e.beat, e.type); },
parameters = new List<Param>()
{ {
new Param("type", KarateMan.HitThree.HitThree, "Type", "The warning text to show") new Param("type", KarateMan.HitThree.HitThree, "Type", "The warning text to show")
}, },
hidden: true), hidden = true
new GameAction("set background color", delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetBgAndShadowCol(e.beat, e.length, e.type, e.type2, e.colorA, e.colorB, (int) KarateMan.currentBgEffect); }, 0.5f, false, },
new List<Param>() new GameAction("hit4", "")
{
function = delegate { KarateMan.instance.DoWord(eventCaller.currentEntity.beat, (int) KarateMan.HitThree.HitFour); },
hidden = true
},
new GameAction("set background color", "")
{
function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetBgAndShadowCol(e.beat, e.length, e.type, e.type2, e.colorA, e.colorB, (int) KarateMan.currentBgEffect); },
defaultLength = 0.5f,
parameters = new List<Param>()
{ {
new Param("type", KarateMan.BackgroundType.Yellow, "Background Type", "The preset background type"), new Param("type", KarateMan.BackgroundType.Yellow, "Background Type", "The preset background type"),
new Param("type2", KarateMan.ShadowType.Tinted, "Shadow Type", "The shadow type. If Tinted doesn't work with your background color try Custom"), new Param("type2", KarateMan.ShadowType.Tinted, "Shadow Type", "The shadow type. If Tinted doesn't work with your background color try Custom"),
@ -121,22 +213,32 @@ namespace HeavenStudio.Games.Loaders
new Param("colorB", new Color(), "Custom Shadow Color", "The shadow color to use when shadow type is set to Custom"), new Param("colorB", new Color(), "Custom Shadow Color", "The shadow color to use when shadow type is set to Custom"),
}, },
hidden: true), hidden = true
new GameAction("set background fx", delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetBgFx(e.type, e.beat, e.length); }, 0.5f, false, new List<Param>()
{
new Param("type", KarateMan.BackgroundFXType.None, "FX Type", "The background effect to be displayed")
}, },
hidden: true), new GameAction("set background fx", "")
new GameAction("set background texture", delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetBgTexture(e.type, e.type2, e.colorA, e.colorB); }, 0.5f, false, new List<Param>()
{ {
new Param("type", KarateMan.BackgroundTextureType.Plain, "Texture", "The type of background texture to use"), function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetBgFx(e.type, e.beat, e.length); },
new Param("type2", KarateMan.ShadowType.Tinted, "Color Filter Type", "The method used to apply colour to the texture"), defaultLength = 0.5f,
new Param("colorA", new Color(), "Custom Filter Color", "The filter color to use when color filter type is set to Custom"), parameters = new List<Param>()
new Param("colorB", new Color(), "Fading Filter Color", "When using the Fade background effect, make filter colour fade to this colour"), {
new Param("type", KarateMan.BackgroundFXType.None, "FX Type", "The background effect to be displayed")
},
hidden = true
}, },
hidden: true),
new GameAction("set background texture", "")
{
function = delegate { var e = eventCaller.currentEntity; KarateMan.instance.SetBgTexture(e.type, e.type2, e.colorA, e.colorB); },
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("type", KarateMan.BackgroundTextureType.Plain, "Texture", "The type of background texture to use"),
new Param("type2", KarateMan.ShadowType.Tinted, "Color Filter Type", "The method used to apply colour to the texture"),
new Param("colorA", new Color(), "Custom Filter Color", "The filter color to use when color filter type is set to Custom"),
new Param("colorB", new Color(), "Fading Filter Color", "When using the Fade background effect, make filter colour fade to this colour"),
},
hidden = true
},
}, },
new List<string>() {"agb", "ntr", "rvl", "ctr", "pco", "normal"}, new List<string>() {"agb", "ntr", "rvl", "ctr", "pco", "normal"},
"karate", "en", "karate", "en",

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

@ -15,25 +15,38 @@ namespace HeavenStudio.Games.Loaders
return new Minigame("pajamaParty", "Pajama Party", "965076", false, false, new List<GameAction>() return new Minigame("pajamaParty", "Pajama Party", "965076", false, false, new List<GameAction>()
{ {
// both same timing // both same timing
new GameAction("jump (side to middle)", delegate {PajamaParty.instance.DoThreeJump(eventCaller.currentEntity.beat);}, 4f, false, new GameAction("jump (side to middle)", "Side to Middle Jumps")
inactiveFunction: delegate {PajamaParty.WarnThreeJump(eventCaller.currentEntity.beat);} {
), function = delegate {PajamaParty.instance.DoThreeJump(eventCaller.currentEntity.beat);},
new GameAction("jump (back to front)", delegate {PajamaParty.instance.DoFiveJump(eventCaller.currentEntity.beat);}, 4f, false, defaultLength = 4f,
inactiveFunction: delegate {PajamaParty.WarnFiveJump(eventCaller.currentEntity.beat);} inactiveFunction = delegate {PajamaParty.WarnThreeJump(eventCaller.currentEntity.beat);}
), },
new GameAction("jump (back to front)", "Back to Front Jumps")
{
function =delegate {PajamaParty.instance.DoFiveJump(eventCaller.currentEntity.beat);},
defaultLength = 4f,
inactiveFunction = delegate {PajamaParty.WarnFiveJump(eventCaller.currentEntity.beat);}
},
//idem //idem
new GameAction("slumber", delegate {var e = eventCaller.currentEntity; PajamaParty.instance.DoSleepSequence(e.beat, e.toggle, e.type);}, 8f, false, parameters: new List<Param>() new GameAction("slumber", "Slumber")
{
function = delegate {var e = eventCaller.currentEntity; PajamaParty.instance.DoSleepSequence(e.beat, e.toggle, e.type);},
defaultLength = 8f,
parameters = new List<Param>()
{ {
new Param("type", PajamaParty.SleepType.Normal, "Sleep Type", "Type of sleep action to use"), 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("toggle", false, "Alt. Animation", "Use an alternate animation for Mako")
}, },
inactiveFunction: delegate {var e = eventCaller.currentEntity; PajamaParty.WarnSleepSequence(e.beat, e.toggle);} inactiveFunction = delegate {var e = eventCaller.currentEntity; PajamaParty.WarnSleepSequence(e.beat, e.toggle);}
), },
new GameAction("throw", delegate {PajamaParty.instance.DoThrowSequence(eventCaller.currentEntity.beat);}, 8f, false, new GameAction("throw", "Throw Pillows")
inactiveFunction: delegate {PajamaParty.WarnThrowSequence(eventCaller.currentEntity.beat);} {
), function = delegate {PajamaParty.instance.DoThrowSequence(eventCaller.currentEntity.beat);},
//cosmetic defaultLength = 8f,
// new GameAction("open / close background", delegate { }, 2f, true), inactiveFunction = delegate {PajamaParty.WarnThrowSequence(eventCaller.currentEntity.beat);}
},
// todo cosmetic crap
// background stuff
// do shit with mako's face? (talking?) // do shit with mako's face? (talking?)
}, },
new List<string>() {"ctr", "normal"}, new List<string>() {"ctr", "normal"},

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

@ -15,32 +15,74 @@ namespace HeavenStudio.Games.Loaders
public static Minigame AddGame(EventCaller eventCaller) { public static Minigame AddGame(EventCaller eventCaller) {
return new Minigame("rhythmTweezers", "Rhythm Tweezers", "98b389", false, false, new List<GameAction>() return new Minigame("rhythmTweezers", "Rhythm Tweezers", "98b389", false, false, new List<GameAction>()
{ {
new GameAction("start interval", delegate { RhythmTweezers.instance.SetIntervalStart(eventCaller.currentEntity.beat, eventCaller.currentEntity.length); }, 4f, true), new GameAction("start interval", "Start Interval")
new GameAction("short hair", delegate { RhythmTweezers.instance.SpawnHair(eventCaller.currentEntity.beat); }, 0.5f),
new GameAction("long hair", delegate { RhythmTweezers.instance.SpawnLongHair(eventCaller.currentEntity.beat); }, 0.5f),
new GameAction("next vegetable", delegate { var e = eventCaller.currentEntity; RhythmTweezers.instance.NextVegetable(e.beat, e.type, e.colorA, e.colorB); }, 0.5f, false, new List<Param>()
{ {
new Param("type", RhythmTweezers.VegetableType.Onion, "Type", "The vegetable to switch to"), function = delegate { RhythmTweezers.instance.SetIntervalStart(eventCaller.currentEntity.beat, eventCaller.currentEntity.length); },
new Param("colorA", RhythmTweezers.defaultOnionColor, "Onion Color", "The color of the onion"), defaultLength = 4f,
new Param("colorB", RhythmTweezers.defaultPotatoColor, "Potato Color", "The color of the potato") resizable = true
} ), },
new GameAction("change vegetable", delegate { var e = eventCaller.currentEntity; RhythmTweezers.instance.ChangeVegetableImmediate(e.type, e.colorA, e.colorB); }, 0.5f, false, new List<Param>() new GameAction("short hair", "Short Hair")
{ {
new Param("type", RhythmTweezers.VegetableType.Onion, "Type", "The vegetable to switch to"),
new Param("colorA", RhythmTweezers.defaultOnionColor, "Onion Color", "The color of the onion"), function = delegate { RhythmTweezers.instance.SpawnHair(eventCaller.currentEntity.beat); },
new Param("colorB", RhythmTweezers.defaultPotatoColor, "Potato Color", "The color of the potato") defaultLength = 0.5f
} ), },
new GameAction("set tweezer delay", delegate { RhythmTweezers.instance.tweezerBeatOffset = eventCaller.currentEntity.length; }, 1f, true), new GameAction("long hair", "Curly Hair")
new GameAction("reset tweezer delay", delegate { RhythmTweezers.instance.tweezerBeatOffset = 0f; }, 0.5f),
new GameAction("set background color", delegate { var e = eventCaller.currentEntity; RhythmTweezers.instance.ChangeBackgroundColor(e.colorA, 0f); }, 0.5f, false, new List<Param>()
{ {
new Param("colorA", RhythmTweezers.defaultBgColor, "Background Color", "The background color to change to") function = delegate { RhythmTweezers.instance.SpawnLongHair(eventCaller.currentEntity.beat); },
} ), defaultLength = 0.5f
new GameAction("fade background color", delegate { var e = eventCaller.currentEntity; RhythmTweezers.instance.FadeBackgroundColor(e.colorA, e.colorB, e.length); }, 1f, true, new List<Param>() },
new GameAction("next vegetable", "Swap Vegetable")
{ {
new Param("colorA", Color.white, "Start Color", "The starting color in the fade"), function = delegate { var e = eventCaller.currentEntity; RhythmTweezers.instance.NextVegetable(e.beat, e.type, e.colorA, e.colorB); },
new Param("colorB", RhythmTweezers.defaultBgColor, "End Color", "The ending color in the fade") 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 GameAction("change vegetable", "Change Vegetable (Instant)")
{
function = delegate { var e = eventCaller.currentEntity; RhythmTweezers.instance.ChangeVegetableImmediate(e.type, e.colorA, e.colorB); },
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 GameAction("set tweezer delay", "Offset Tweezer")
{
function = delegate { RhythmTweezers.instance.tweezerBeatOffset = eventCaller.currentEntity.length; },
resizable = true
},
new GameAction("reset tweezer delay", "Reset Tweezer Offset")
{
function = delegate { RhythmTweezers.instance.tweezerBeatOffset = 0f; },
defaultLength = 0.5f
},
new GameAction("set background color", "Background Colour")
{
function = delegate { var e = eventCaller.currentEntity; RhythmTweezers.instance.ChangeBackgroundColor(e.colorA, 0f); },
defaultLength = 0.5f,
parameters = new List<Param>()
{
new Param("colorA", RhythmTweezers.defaultBgColor, "Background Color", "The background color to change to")
}
},
new GameAction("fade background color", "Background Fade")
{
function = delegate { var e = eventCaller.currentEntity; RhythmTweezers.instance.FadeBackgroundColor(e.colorA, e.colorB, e.length); },
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")
}
}
}); });
} }
} }

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

@ -14,15 +14,19 @@ namespace HeavenStudio.Games.Loaders
public static Minigame AddGame(EventCaller eventCaller) { public static Minigame AddGame(EventCaller eventCaller) {
return new Minigame("samuraiSliceNtr", "Samurai Slice (DS)", "00165D", false, false, new List<GameAction>() return new Minigame("samuraiSliceNtr", "Samurai Slice (DS)", "00165D", false, false, new List<GameAction>()
{ {
new GameAction("spawn object", delegate new GameAction("spawn object", "Toss Object")
{ {
SamuraiSliceNtr.instance.ObjectIn(eventCaller.currentEntity.beat, eventCaller.currentEntity.type, (int) eventCaller.currentEntity.valA); function = delegate
}, 8, false, new List<Param>() {
{ SamuraiSliceNtr.instance.ObjectIn(eventCaller.currentEntity.beat, eventCaller.currentEntity.type, (int) eventCaller.currentEntity.valA);
new Param("type", SamuraiSliceNtr.ObjectType.Melon, "Object", "The object to spawn"), },
new Param("valA", new EntityTypes.Integer(0, 30, 1), "Money", "The amount of coins the object spills out when sliced"), defaultLength = 8,
}), parameters = new List<Param>()
//new GameAction("start bopping", delegate { SamuraiSliceNtr.instance.Bop(eventCaller.currentEntity.beat, eventCaller.currentEntity.length); }, 1), {
new Param("type", SamuraiSliceNtr.ObjectType.Melon, "Object", "The object to spawn"),
new Param("valA", new EntityTypes.Integer(0, 30, 1), "Money", "The amount of coins the object spills out when sliced"),
}
},
}, },
new List<string>() {"ntr", "normal"}, new List<string>() {"ntr", "normal"},
"ntrsamurai", "en", "ntrsamurai", "en",

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

@ -12,25 +12,51 @@ namespace HeavenStudio.Games.Loaders
public static Minigame AddGame(EventCaller eventCaller) { public static Minigame AddGame(EventCaller eventCaller) {
return new Minigame("spaceball", "Spaceball", "00A518", false, false, new List<GameAction>() return new Minigame("spaceball", "Spaceball", "00A518", false, false, new List<GameAction>()
{ {
new GameAction("shoot", delegate { Spaceball.instance.Shoot(eventCaller.currentEntity.beat, false, eventCaller.currentEntity.type); }, 2, false, new List<Param>() new GameAction("shoot", "Pitch Ball")
{ {
new Param("type", Spaceball.BallType.Baseball, "Type", "The type of ball/object to shoot") function = delegate { Spaceball.instance.Shoot(eventCaller.currentEntity.beat, false, eventCaller.currentEntity.type); },
} ), defaultLength = 2,
new GameAction("shootHigh", delegate { Spaceball.instance.Shoot(eventCaller.currentEntity.beat, true, eventCaller.currentEntity.type); }, 3, false, new List<Param>() parameters = new List<Param>()
{
new Param("type", Spaceball.BallType.Baseball, "Type", "The type of ball/object to shoot")
}
},
new GameAction("shootHigh", "Pitch High Ball")
{ {
new Param("type", Spaceball.BallType.Baseball, "Type", "The type of ball/object to shoot") function = delegate { Spaceball.instance.Shoot(eventCaller.currentEntity.beat, true, eventCaller.currentEntity.type); },
} ), defaultLength = 3,
new GameAction("costume", delegate { Spaceball.instance.Costume(eventCaller.currentEntity.type); }, 1f, false, new List<Param>() parameters = new List<Param>()
{
new Param("type", Spaceball.BallType.Baseball, "Type", "The type of ball/object to shoot")
}
},
new GameAction("costume", "Change Batter Costume")
{ {
new Param("type", Spaceball.CostumeType.Standard, "Type", "The costume to change to") function = delegate { Spaceball.instance.Costume(eventCaller.currentEntity.type); },
} ), parameters = new List<Param>()
new GameAction("alien", delegate { Spaceball.instance.alien.Show(eventCaller.currentEntity.beat); } ), {
new GameAction("camera", delegate { Spaceball.instance.OverrideCurrentZoom(); }, 4, true, new List<Param>() new Param("type", Spaceball.CostumeType.Standard, "Type", "The costume to change to")
}
},
new GameAction("alien", "Show Alien")
{ {
new Param("valA", new EntityTypes.Integer(1, 320, 10), "Zoom", "The camera's zoom level (Lower value = Zoomed in)"), function = delegate { Spaceball.instance.alien.Show(eventCaller.currentEntity.beat); }
new Param("ease", EasingFunction.Ease.Linear, "Ease", "The easing function to use while zooming") },
} ), new GameAction("camera", "Zoom Camera")
new GameAction("prepare dispenser", delegate { Spaceball.instance.PrepareDispenser(); }, 1 ), {
function = delegate { Spaceball.instance.OverrideCurrentZoom(); },
defaultLength = 4,
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", EasingFunction.Ease.Linear, "Ease", "The easing function to use while zooming")
}
},
new GameAction("prepare dispenser", "Dispenser Prepare")
{
function = delegate { Spaceball.instance.PrepareDispenser(); },
},
}); });
} }
} }

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

@ -14,26 +14,72 @@ namespace HeavenStudio.Games.Loaders
public static Minigame AddGame(EventCaller eventCaller) { public static Minigame AddGame(EventCaller eventCaller) {
return new Minigame("tapTrial", "Tap Trial \n<color=#eb5454>[WIP]</color>", "93ffb3", false, false, new List<GameAction>() return new Minigame("tapTrial", "Tap Trial \n<color=#eb5454>[WIP]</color>", "93ffb3", false, false, new List<GameAction>()
{ {
new GameAction("bop", delegate { TapTrial.instance.Bop(eventCaller.currentEntity.toggle); }, .5f, false, new List<Param>() new GameAction("bop", "Bop")
{ {
new Param("toggle", true, "Bop", "Whether both will bop to the beat or not") function = delegate { TapTrial.instance.Bop(eventCaller.currentEntity.toggle); },
}), defaultLength = .5f,
new GameAction("tap", delegate { TapTrial.instance.Tap(eventCaller.currentEntity.beat); }, 2.0f, false), parameters = new List<Param>()
new GameAction("double tap", delegate { TapTrial.instance.DoubleTap(eventCaller.currentEntity.beat); }, 2.0f, false), {
new GameAction("triple tap", delegate { TapTrial.instance.TripleTap(eventCaller.currentEntity.beat); }, 4.0f, false), new Param("toggle", true, "Bop", "Whether both will bop to the beat or not")
new GameAction("jump tap prep", delegate { TapTrial.instance.JumpTapPrep(eventCaller.currentEntity.beat); }, 1.0f, false), }
new GameAction("jump tap", delegate { TapTrial.instance.JumpTap(eventCaller.currentEntity.beat); }, 2.0f, false), },
new GameAction("final jump tap", delegate { TapTrial.instance.FinalJumpTap(eventCaller.currentEntity.beat); }, 2.0f, false), new GameAction("tap", "Tap")
new GameAction("scroll event", delegate { TapTrial.instance.scrollEvent(eventCaller.currentEntity.toggle, eventCaller.currentEntity.toggle); }, .5f, false, new List<Param>()
{ {
new Param("toggle", false, "Scroll FX", "Will scroll"),
new Param("toggle", false, "Flash FX", "Will flash to white"), function = delegate { TapTrial.instance.Tap(eventCaller.currentEntity.beat); },
}), defaultLength = 2.0f
new GameAction("giraffe events", delegate { TapTrial.instance.giraffeEvent(eventCaller.currentEntity.toggle, eventCaller.currentEntity.toggle); }, .5f, false, new List<Param>() },
new GameAction("double tap", "Double Tap")
{ {
new Param("toggle", false, "Enter", "Giraffe will enter the scene"),
new Param("toggle", false, "Exit", "Giraffe will exit the scene"), function = delegate { TapTrial.instance.DoubleTap(eventCaller.currentEntity.beat); },
}) defaultLength = 2.0f
},
new GameAction("triple tap", "Triple Tap")
{
function = delegate { TapTrial.instance.TripleTap(eventCaller.currentEntity.beat); },
defaultLength = 4.0f
},
new GameAction("jump tap prep", "Prepare Stance")
{
function = delegate { TapTrial.instance.JumpTapPrep(eventCaller.currentEntity.beat); },
},
new GameAction("jump tap", "Jump Tap")
{
function = delegate { TapTrial.instance.JumpTap(eventCaller.currentEntity.beat); },
defaultLength = 2.0f
},
new GameAction("final jump tap", "Final Jump Tap")
{
function = delegate { TapTrial.instance.FinalJumpTap(eventCaller.currentEntity.beat); },
defaultLength = 2.0f
},
new GameAction("scroll event", "Scroll Background")
{
function = delegate { TapTrial.instance.scrollEvent(eventCaller.currentEntity.toggle, eventCaller.currentEntity.toggle); },
defaultLength = .5f,
parameters = new List<Param>()
{
new Param("toggle", false, "Scroll FX", "Will scroll"),
new Param("toggle", false, "Flash FX", "Will flash to white"),
}
},
new GameAction("giraffe events", "Giraffe Animations")
{
function = delegate { TapTrial.instance.giraffeEvent(eventCaller.currentEntity.toggle, eventCaller.currentEntity.toggle); },
defaultLength = .5f,
parameters = new List<Param>()
{
new Param("toggle", false, "Enter", "Giraffe will enter the scene"),
new Param("toggle", false, "Exit", "Giraffe will exit the scene"),
}
}
}); });
} }
} }

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

@ -15,14 +15,24 @@ namespace HeavenStudio.Games.Loaders
public static Minigame AddGame(EventCaller eventCaller) { public static Minigame AddGame(EventCaller eventCaller) {
return new Minigame("trickClass", "Trick on the Class", "C0171D", false, false, new List<GameAction>() return new Minigame("trickClass", "Trick on the Class", "C0171D", false, false, new List<GameAction>()
{ {
new GameAction("toss", delegate new GameAction("toss", "Toss Object")
{ {
TrickClass.instance.TossObject(eventCaller.currentEntity.beat, eventCaller.currentEntity.type); function = delegate
}, 3, false, new List<Param>() {
TrickClass.instance.TossObject(eventCaller.currentEntity.beat, eventCaller.currentEntity.type);
},
defaultLength = 3,
parameters = new List<Param>()
{
new Param("type", TrickClass.TrickObjType.Ball, "Object", "The object to toss")
}
},
new GameAction("bop", "")
{ {
new Param("type", TrickClass.TrickObjType.Ball, "Object", "The object to toss") function = delegate { var e = eventCaller.currentEntity; TrickClass.instance.Bop(e.beat, e.length); },
}), resizable = true,
new GameAction("bop", delegate { var e = eventCaller.currentEntity; TrickClass.instance.Bop(e.beat, e.length); }, 1, true, hidden: true), hidden = true
},
}); });
} }
} }

347
Assets/Scripts/Minigames.cs
View file

@ -136,35 +136,56 @@ namespace HeavenStudio
public class GameAction public class GameAction
{ {
public string actionName; public string actionName;
public string displayName;
public EventCallback function; public EventCallback function;
public float defaultLength; public float defaultLength;
public bool resizable; public bool resizable;
public List<Param> parameters; public List<Param> parameters;
public bool hidden; public bool hidden;
public EventCallback inactiveFunction; public EventCallback inactiveFunction;
public EventCallback preFunction;
/// <summary> /// <summary>
/// <para>Creates a block that can be used in the editor. The block's function and attributes are defined in the parentheses.</para> /// <para>Creates a block that can be used in the editor. The block's function and attributes are defined in the parentheses.</para>
/// <para>Note: Every parameter after the second one is an optional parameter. You can change optional parameters by adding (name): (value) after the second parameter.</para> /// <para>Note: Every parameter after the second one is an optional parameter. You can change optional parameters by adding (name): (value) after the second parameter.</para>
/// </summary> /// </summary>
/// <param name="actionName">Name of the block</param> /// <param name="actionName">Entity model name</param>
/// <param name="function"><para>What the block does when read during playback</para> /// <param name="displayName">Name of the block used in the UI</param>
/// <para>Only does this if the game that it is associated with is loaded.</para></param>
/// <param name="defaultLength">How long the block appears in the editor</param> /// <param name="defaultLength">How long the block appears in the editor</param>
/// <param name="resizable">Allows the user to resize the block</param> /// <param name="resizable">Allows the user to resize the block</param>
/// <param name="parameters">Extra parameters for this block that change how it functions.</param> /// <param name="parameters">Extra parameters for this block that change how it functions.</param>
/// <param name="hidden">Prevents the block from being shown in the game list. Block will still function normally if it is in the timeline.</param> /// <param name="function"><para>What the block does when read during playback</para>
/// <para>Only does this if the game that it is associated with is loaded.</para></param>
/// <param name="inactiveFunction">What the block does when read while the game it's associated with isn't loaded.</param> /// <param name="inactiveFunction">What the block does when read while the game it's associated with isn't loaded.</param>
public GameAction(string actionName, EventCallback function, float defaultLength = 1, bool resizable = false, List<Param> parameters = null, bool hidden = false, EventCallback inactiveFunction = null) /// <param name="prescheduleFunction">What the block does when the GameManager seeks to this cue for pre-scheduling.</param>
/// <param name="hidden">Prevents the block from being shown in the game list. Block will still function normally if it is in the timeline.</param>
public GameAction(string actionName, string displayName, float defaultLength = 1, bool resizable = false, List<Param> parameters = null, EventCallback function = null, EventCallback inactiveFunction = null, EventCallback prescheduleFunction = null, bool hidden = false)
{ {
this.actionName = actionName; this.actionName = actionName;
this.function = function; if (displayName == String.Empty) this.displayName = actionName;
else this.displayName = displayName;
this.defaultLength = defaultLength; this.defaultLength = defaultLength;
this.resizable = resizable; this.resizable = resizable;
this.parameters = parameters; this.parameters = parameters;
this.hidden = hidden; this.hidden = hidden;
if(inactiveFunction == null) inactiveFunction = delegate { };
this.inactiveFunction = inactiveFunction; this.function = function ?? delegate { };
this.inactiveFunction = inactiveFunction ?? delegate { };
this.preFunction = prescheduleFunction ?? delegate { };
//todo: converting to new versions of GameActions
}
/// <summary>
/// <para>Shorthand constructor for a GameAction with only required data</para>
/// </summary>
/// <param name="actionName">Entity model name</param>
/// <param name="displayName">Name of the block used in the UI</param>
public GameAction(string actionName, string displayName)
{
this.actionName = actionName;
if (displayName == String.Empty) this.displayName = actionName;
else this.displayName = displayName;
} }
} }
@ -179,7 +200,7 @@ namespace HeavenStudio
/// <summary> /// <summary>
/// A parameter that changes the function of a GameAction. /// A parameter that changes the function of a GameAction.
/// </summary> /// </summary>
/// <param name="propertyName">The name of the variable that's being changed. Must be one of the variables in <see cref="Beatmap.Entity"/></param> /// <param name="propertyName">The name of the variable that's being changed.</param>
/// <param name="parameter">The value of the parameter</param> /// <param name="parameter">The value of the parameter</param>
/// <param name="propertyCaption">The name shown in the editor. Can be anything you want.</param> /// <param name="propertyCaption">The name shown in the editor. Can be anything you want.</param>
public Param(string propertyName, object parameter, string propertyCaption, string tooltip = "") public Param(string propertyName, object parameter, string propertyCaption, string tooltip = "")
@ -192,6 +213,7 @@ namespace HeavenStudio
} }
public delegate void EventCallback(); public delegate void EventCallback();
public delegate void ParamChangeCallback(string paramName, object paramValue, DynamicBeatmap.DynamicEntity entity);
// overengineered af but it's a modified version of // overengineered af but it's a modified version of
// https://stackoverflow.com/a/19877141 // https://stackoverflow.com/a/19877141
@ -216,48 +238,44 @@ namespace HeavenStudio
{ {
new Minigame("gameManager", "Game Manager", "", false, true, new List<GameAction>() new Minigame("gameManager", "Game Manager", "", false, true, new List<GameAction>()
{ {
new GameAction("switchGame", delegate { GameManager.instance.SwitchGame(eventCaller.currentSwitchGame, eventCaller.currentEntity.beat); }, 0.5f, inactiveFunction: delegate { GameManager.instance.SwitchGame(eventCaller.currentSwitchGame, eventCaller.currentEntity.beat); }), new GameAction("switchGame", "Switch Game", 0.5f, false,
new GameAction("end", delegate { function: delegate { GameManager.instance.SwitchGame(eventCaller.currentSwitchGame, eventCaller.currentEntity.beat); },
Debug.Log("end"); inactiveFunction: delegate { GameManager.instance.SwitchGame(eventCaller.currentSwitchGame, eventCaller.currentEntity.beat); }
if (Timeline.instance != null) ),
Timeline.instance?.Stop(0); new GameAction("end", "End Remix",
else function: delegate {
GameManager.instance.Stop(0); Debug.Log("end");
}), if (Timeline.instance != null)
new GameAction("skill star", delegate { }, 1f, true), Timeline.instance?.Stop(0);
else
new GameAction("toggle inputs", delegate GameManager.instance.Stop(0);
{ }
GameManager.instance.ToggleInputs(eventCaller.currentEntity.toggle); ),
}, 0.5f, true, new List<Param>() new GameAction("skill star", "Skill Star", 1f, true),
{ new GameAction("toggle inputs", "Toggle Inputs", 0.5f, true,
new Param("toggle", true, "Enable Inputs") new List<Param>()
}), {
new Param("toggle", true, "Enable Inputs")
},
delegate
{
GameManager.instance.ToggleInputs(eventCaller.currentEntity.toggle);
}
),
// DEPRECATED! Now in VFX // These are still here for backwards-compatibility but are hidden in the editor
new GameAction("flash", delegate new GameAction("flash", "", 1f, true,
{ new List<Param>()
{
/*Color colA = eventCaller.currentEntity.colorA; new Param("colorA", Color.white, "Start Color"),
Color colB = eventCaller.currentEntity.colorB; new Param("colorB", Color.white, "End Color"),
new Param("valA", new EntityTypes.Float(0, 1, 1), "Start Opacity"),
Color startCol = new Color(colA.r, colA.g, colA.b, eventCaller.currentEntity.valA); new Param("valB", new EntityTypes.Float(0, 1, 0), "End Opacity"),
Color endCol = new Color(colB.r, colB.g, colB.b, eventCaller.currentEntity.valB); new Param("ease", EasingFunction.Ease.Linear, "Ease")
},
GameManager.instance.fade.SetFade(eventCaller.currentEntity.beat, eventCaller.currentEntity.length, startCol, endCol, eventCaller.currentEntity.ease);*/ hidden: true
),
}, 1f, true, new List<Param>() new GameAction("move camera", "", 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", EasingFunction.Ease.Linear, "Ease")
}, hidden: true ),
new GameAction("move camera", delegate
{
}, 1f, true, new List<Param>()
{ {
new Param("valA", new EntityTypes.Float(-50, 50, 0), "Right / Left"), new Param("valA", new EntityTypes.Float(-50, 50, 0), "Right / Left"),
new Param("valB", new EntityTypes.Float(-50, 50, 0), "Up / Down"), new Param("valB", new EntityTypes.Float(-50, 50, 0), "Up / Down"),
@ -265,10 +283,7 @@ namespace HeavenStudio
new Param("ease", EasingFunction.Ease.Linear, "Ease Type") new Param("ease", EasingFunction.Ease.Linear, "Ease Type")
}, },
hidden: true ), hidden: true ),
new GameAction("rotate camera", "", 1f, true, new List<Param>()
new GameAction("rotate camera", delegate
{
}, 1f, true, new List<Param>()
{ {
new Param("valA", new EntityTypes.Integer(-360, 360, 0), "Pitch"), new Param("valA", new EntityTypes.Integer(-360, 360, 0), "Pitch"),
new Param("valB", new EntityTypes.Integer(-360, 360, 0), "Yaw"), new Param("valB", new EntityTypes.Integer(-360, 360, 0), "Yaw"),
@ -280,119 +295,131 @@ namespace HeavenStudio
new Minigame("countIn", "Count-Ins", "", false, true, new List<GameAction>() new Minigame("countIn", "Count-Ins", "", false, true, new List<GameAction>()
{ {
new GameAction("4 beat count-in", delegate { var e = eventCaller.currentEntity; SoundEffects.FourBeatCountIn(e.beat, e.length / 4f, e.type); }, 4f, true, new List<Param>() 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", "The sounds to play for the count-in")
new GameAction("8 beat count-in", delegate { var e = eventCaller.currentEntity; SoundEffects.EightBeatCountIn(e.beat, e.length / 8f, e.type); }, 8f, true, new List<Param>() },
{ delegate { var e = eventCaller.currentEntity; SoundEffects.FourBeatCountIn(e.beat, e.length / 4f, e.type); }
new Param("type", SoundEffects.CountInType.Normal, "Type", "The sounds to play for the count-in") ),
}), new GameAction("8 beat count-in", "8 Beat Count-In", 8f, true,
new GameAction("count", delegate { var e = eventCaller.currentEntity; SoundEffects.Count(e.type, e.toggle); }, 1f, false, new List<Param>() new List<Param>()
{ {
new Param("type", SoundEffects.CountNumbers.One, "Number", "The sound to play"), new Param("type", SoundEffects.CountInType.Normal, "Type", "The sounds to play for the count-in")
new Param("toggle", false, "Alt", "Whether or not the alternate version should be played") },
}), delegate { var e = eventCaller.currentEntity; SoundEffects.EightBeatCountIn(e.beat, e.length / 8f, e.type); }
new GameAction("cowbell", delegate { SoundEffects.Cowbell(); }, 1f), ),
new GameAction("ready!", delegate { var e = eventCaller.currentEntity; SoundEffects.Ready(e.beat, e.length / 2f); }, 2f, true), new GameAction("count", "Count", 1f, false,
new GameAction("and", delegate {SoundEffects.And(); }, 0.5f), new List<Param>()
new GameAction("go!", delegate { SoundEffects.Go(eventCaller.currentEntity.toggle); }, 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("toggle", false, "Alt", "Whether or not the alternate version should be played")
}), },
delegate { var e = eventCaller.currentEntity; SoundEffects.Count(e.type, e.toggle); }
),
new GameAction("cowbell", "Cowbell",
function: delegate { SoundEffects.Cowbell(); }
),
new GameAction("ready!", "Ready!", 2f, true,
function: delegate { var e = eventCaller.currentEntity; SoundEffects.Ready(e.beat, e.length / 2f); }
),
new GameAction("and", "And", 0.5f,
function: delegate { SoundEffects.And(); }
),
new GameAction("go!", "Go!", 1f, false,
new List<Param>()
{
new Param("toggle", false, "Alt", "Whether or not the alternate version should be played")
},
function: delegate { SoundEffects.Go(eventCaller.currentEntity.toggle); }
),
// These are still here for backwards-compatibility but are hidden in the editor // These are still here for backwards-compatibility but are hidden in the editor
new GameAction("4 beat count-in (alt)", delegate { var e = eventCaller.currentEntity; SoundEffects.FourBeatCountIn(e.beat, e.length, 1); }, 4f, hidden: true), new GameAction("4 beat count-in (alt)", "", 4f, function: delegate { var e = eventCaller.currentEntity; SoundEffects.FourBeatCountIn(e.beat, e.length, 1); }, hidden: true),
new GameAction("4 beat count-in (cowbell)", delegate { var e = eventCaller.currentEntity; SoundEffects.FourBeatCountIn(e.beat, e.length, 2); }, 4f, hidden: true), new GameAction("4 beat count-in (cowbell)", "", 4f, function: delegate { var e = eventCaller.currentEntity; SoundEffects.FourBeatCountIn(e.beat, e.length, 2); }, hidden: true),
new GameAction("8 beat count-in (alt)", delegate { var e = eventCaller.currentEntity; SoundEffects.EightBeatCountIn(e.beat, e.length, 1); }, 4f, hidden: true), new GameAction("8 beat count-in (alt)", "", 8f, function: delegate { var e = eventCaller.currentEntity; SoundEffects.EightBeatCountIn(e.beat, e.length, 1); }, hidden: true),
new GameAction("8 beat count-in (cowbell)", delegate { var e = eventCaller.currentEntity; SoundEffects.EightBeatCountIn(e.beat, e.length, 2); }, 4f, hidden: true), new GameAction("8 beat count-in (cowbell)", "", 8f, function: delegate { var e = eventCaller.currentEntity; SoundEffects.EightBeatCountIn(e.beat, e.length, 2); }, hidden: true),
new GameAction("one", delegate { SoundEffects.Count(0, false); }, 1f, hidden: true),
new GameAction("one (alt)", delegate { SoundEffects.Count(0, true); }, 1f, hidden: true), new GameAction("one", "", function: delegate { SoundEffects.Count(0, false); }, hidden: true),
new GameAction("two", delegate { SoundEffects.Count(1, false); }, 1f, hidden: true), new GameAction("two", "", function: delegate { SoundEffects.Count(1, false); }, hidden: true),
new GameAction("two (alt)", delegate { SoundEffects.Count(1, true); }, 1f, hidden: true), new GameAction("three", "", function: delegate { SoundEffects.Count(2, false); }, hidden: true),
new GameAction("three", delegate { SoundEffects.Count(2, false); }, 1f, hidden: true), new GameAction("four", "", function: delegate { SoundEffects.Count(3, false); }, hidden: true),
new GameAction("three (alt)", delegate { SoundEffects.Count(2, true); }, 1f, hidden: true), new GameAction("one (alt)", "", function: delegate { SoundEffects.Count(0, true); }, hidden: true),
new GameAction("four", delegate { SoundEffects.Count(3, false); }, 1f, hidden: true), new GameAction("two (alt)", "", function: delegate { SoundEffects.Count(1, true); }, hidden: true),
new GameAction("four (alt)", delegate { SoundEffects.Count(3, true); }, 1f, hidden: true), new GameAction("three (alt)", "", function: delegate { SoundEffects.Count(2, true); }, hidden: true),
new GameAction("go! (alt)", delegate { SoundEffects.Go(true); }, 1f, hidden: true), new GameAction("four (alt)", "", function: delegate { SoundEffects.Count(3, true); }, hidden: true),
new GameAction("go! (alt)", "", function: delegate { SoundEffects.Go(true); }, hidden: true),
}), }),
new Minigame("vfx", "Visual Effects", "", false, true, new List<GameAction>() new Minigame("vfx", "Visual Effects", "", false, true, new List<GameAction>()
{ {
new GameAction("flash", delegate 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", EasingFunction.Ease.Linear, "Ease")
}
),
new GameAction("move camera", "Move Camera", 1f, true, new List<Param>()
{
new Param("valA", new EntityTypes.Float(-50, 50, 0), "Right / Left"),
new Param("valB", new EntityTypes.Float(-50, 50, 0), "Up / Down"),
new Param("valC", new EntityTypes.Float(-0, 250, 10), "In / Out"),
new Param("ease", EasingFunction.Ease.Linear, "Ease Type")
}
),
new GameAction("rotate camera", "Rotate Camera", 1f, true, new List<Param>()
{
new Param("valA", new EntityTypes.Integer(-360, 360, 0), "Pitch"),
new Param("valB", new EntityTypes.Integer(-360, 360, 0), "Yaw"),
new Param("valC", new EntityTypes.Integer(-360, 360, 0), "Roll"),
new Param("ease", EasingFunction.Ease.Linear, "Ease Type")
}
),
/*Color colA = eventCaller.currentEntity.colorA; new GameAction("screen shake", "Screen Shake", 1f, true,
Color colB = eventCaller.currentEntity.colorB; 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")
}
),
Color startCol = new Color(colA.r, colA.g, colA.b, eventCaller.currentEntity.valA); new GameAction("display textbox", "Display Textbox", 1f, true, new List<Param>()
Color endCol = new Color(colB.r, colB.g, colB.b, eventCaller.currentEntity.valB); {
new Param("text1", "", "Text", "The text to display in the textbox (Rich Text is supported!)"),
GameManager.instance.fade.SetFade(eventCaller.currentEntity.beat, eventCaller.currentEntity.length, startCol, endCol, eventCaller.currentEntity.ease);*/ 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"),
}, 1f, true, new List<Param>() new Param("valB", new EntityTypes.Float(0.5f, 8, 1), "Textbox Height", "Textbox height multiplier")
{ }
new Param("colorA", Color.white, "Start Color"), ),
new Param("colorB", Color.white, "End Color"), new GameAction("display open captions", "Display Open Captions", 1f, true,
new Param("valA", new EntityTypes.Float(0, 1, 1), "Start Opacity"), new List<Param>()
new Param("valB", new EntityTypes.Float(0, 1, 0), "End Opacity"), {
new Param("ease", EasingFunction.Ease.Linear, "Ease") new Param("text1", "", "Text", "The text to display in the captions (Rich Text is supported!)"),
}, hidden: false ), 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 GameAction("move camera", delegate {}, 1f, true, new List<Param>() new Param("valB", new EntityTypes.Float(0.5f, 8, 1), "Captions Height", "Captions height multiplier")
{ }
new Param("valA", new EntityTypes.Float(-50, 50, 0), "Right / Left"), ),
new Param("valB", new EntityTypes.Float(-50, 50, 0), "Up / Down"), new GameAction("display closed captions", "Display Closed Captions", 1f, true,
new Param("valC", new EntityTypes.Float(-0, 250, 10), "In / Out"), new List<Param>()
new Param("ease", EasingFunction.Ease.Linear, "Ease Type") {
} ), 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 GameAction("rotate camera", delegate {}, 1f, true, new List<Param>() new Param("valA", new EntityTypes.Float(0.5f, 4, 1), "Captions Height", "Captions height multiplier")
{ }
new Param("valA", new EntityTypes.Integer(-360, 360, 0), "Pitch"), ),
new Param("valB", new EntityTypes.Integer(-360, 360, 0), "Yaw"), new GameAction("display song artist", "Display Song Info", 1f, true,
new Param("valC", new EntityTypes.Integer(-360, 360, 0), "Roll"), new List<Param>()
new Param("ease", EasingFunction.Ease.Linear, "Ease Type") {
} ), 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 GameAction("screen shake", delegate {}, 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 GameAction("display textbox", delegate
{
}, 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 GameAction("display open captions", delegate
{
}, 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 GameAction("display closed captions", delegate
{
}, 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 GameAction("display song artist", delegate
{
}, 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!)"),
} ),
}), }),
}; };