etc/HeavenStudioPlus
0
0
Fork 0
mirror of https://github.com/RHeavenStudioPlus/HeavenStudioPlus.git synced 2024-11-10 19:55:09 +00:00
Code Issues Projects Releases Packages Wiki Activity
HeavenStudioPlus/Assets/Scripts/Minigames.cs

344 lines
24 KiB
C#
Raw Normal View History

Buggy timeline object resizing
2022-01-17 19:23:18 +00:00
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using RhythmHeavenMania.Util;
using RhythmHeavenMania.Games.ForkLifter;
using RhythmHeavenMania.Games.ClappyTrio;
using RhythmHeavenMania.Games.Spaceball;
using RhythmHeavenMania.Games.KarateMan;
I'm tired
2022-01-24 02:15:23 +00:00
using RhythmHeavenMania.Games.SpaceSoccer;
DJ School sounds
2022-02-03 02:09:50 +00:00
using RhythmHeavenMania.Games.DJSchool;
Tweezers: Functioning gameplay loop + Editor implementation.
2022-02-09 10:29:09 +00:00
using RhythmHeavenMania.Games.RhythmTweezers;
Rhythm Rally: Animations baybeeeeeeeeee
2022-02-12 08:12:12 +00:00
using RhythmHeavenMania.Games.RhythmRally;
Built to Scale: Gameplay implemented (missing lots of sfx)
2022-02-16 17:04:28 +00:00
using RhythmHeavenMania.Games.BuiltToScaleDS;
Some tap trial setup
2022-02-19 18:51:46 +00:00
using RhythmHeavenMania.Games.TapTrial;
Buggy timeline object resizing
2022-01-17 19:23:18 +00:00
namespace RhythmHeavenMania
{
public class Minigames
{
public class Minigame
{
public string name;
public string displayName;
public string color;
public GameObject holder;
DJ School sounds
2022-02-03 02:09:50 +00:00
public bool threeD;
Count ins and event selector cleanup
2022-02-03 03:58:08 +00:00
public bool fxOnly;
Buggy timeline object resizing
2022-01-17 19:23:18 +00:00
public List<GameAction> actions = new List<GameAction>();
Count ins and event selector cleanup
2022-02-03 03:58:08 +00:00
public Minigame(string name, string displayName, string color, bool threeD, bool fxOnly, List<GameAction> actions)
Buggy timeline object resizing
2022-01-17 19:23:18 +00:00
{
this.name = name;
this.displayName = displayName;
this.color = color;
this.actions = actions;
Count ins and event selector cleanup
2022-02-03 03:58:08 +00:00
this.threeD = threeD;
this.fxOnly = fxOnly;
Buggy timeline object resizing
2022-01-17 19:23:18 +00:00
}
}
public class GameAction
{
public string actionName;
public EventCallback function;
public float defaultLength;
public bool resizable;
Entity object parameters testing
2022-02-03 22:20:26 +00:00
public List<Param> parameters;
Buggy timeline object resizing
2022-01-17 19:23:18 +00:00
Entity object parameters testing
2022-02-03 22:20:26 +00:00
public GameAction(string actionName, EventCallback function, float defaultLength = 1, bool resizable = false, List<Param> parameters = null)
Buggy timeline object resizing
2022-01-17 19:23:18 +00:00
{
this.actionName = actionName;
this.function = function;
this.defaultLength = defaultLength;
this.resizable = resizable;
Entity object parameters testing
2022-02-03 22:20:26 +00:00
this.parameters = parameters;
}
}
[System.Serializable]
public class Param
{
public string propertyName;
public object parameter;
public string propertyCaption;
public Param(string propertyName, object parameter, string propertyCaption)
{
this.propertyName = propertyName;
this.parameter = parameter;
this.propertyCaption = propertyCaption;
Buggy timeline object resizing
2022-01-17 19:23:18 +00:00
}
}
public delegate void EventCallback();
public static void Init(EventCaller eventCaller)
{
eventCaller.minigames = new List<Minigame>()
{
Count ins and event selector cleanup
2022-02-03 03:58:08 +00:00
new Minigame("gameManager", "Game Manager", "", false, true, new List<GameAction>()
Buggy timeline object resizing
2022-01-17 19:23:18 +00:00
{
bread2unity BCCAD interpreter setup
2022-02-10 08:13:54 +00:00
new GameAction("switchGame", delegate { GameManager.instance.SwitchGame(eventCaller.currentSwitchGame); }, 0.5f),
new GameAction("end", delegate { Debug.Log("end"); }),
new GameAction("skill star", delegate { }, 1f, true),
new GameAction("flash", delegate
Camera flashes (bug associated with fullscreen)
2022-02-08 01:07:03 +00:00
{
/*Color colA = eventCaller.currentEntity.colorA;
Color colB = eventCaller.currentEntity.colorB;
Color startCol = new Color(colA.r, colA.g, colA.b, eventCaller.currentEntity.valA);
Color endCol = new Color(colB.r, colB.g, colB.b, eventCaller.currentEntity.valB);
GameManager.instance.fade.SetFade(eventCaller.currentEntity.beat, eventCaller.currentEntity.length, startCol, endCol, eventCaller.currentEntity.ease);*/
}, 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")
} ),
Buggy timeline object resizing
2022-01-17 19:23:18 +00:00
}),
Count ins and event selector cleanup
2022-02-03 03:58:08 +00:00
new Minigame("countIn", "Count-Ins", "", false, true, new List<GameAction>()
{
Some small stuff Changed the window title to the new name and added some full count-ins
2022-02-25 06:59:18 +00:00
new GameAction("4 beat count-in", delegate
{
MultiSound.Play(new MultiSound.Sound[]
{
new MultiSound.Sound("count-ins/one1", eventCaller.currentEntity.beat),
new MultiSound.Sound("count-ins/two1", eventCaller.currentEntity.beat + 1f),
new MultiSound.Sound("count-ins/three1", eventCaller.currentEntity.beat + 2f),
new MultiSound.Sound("count-ins/four1", eventCaller.currentEntity.beat + 3f)
}, false);
}, 4f),
new GameAction("4 beat count-in (alt)", delegate
{
MultiSound.Play(new MultiSound.Sound[]
{
new MultiSound.Sound("count-ins/one2", eventCaller.currentEntity.beat),
new MultiSound.Sound("count-ins/two2", eventCaller.currentEntity.beat + 1f),
new MultiSound.Sound("count-ins/three2", eventCaller.currentEntity.beat + 2f),
new MultiSound.Sound("count-ins/four2", eventCaller.currentEntity.beat + 3f)
}, false);
}, 4f),
new GameAction("4 beat count-in (cowbell)", delegate
{
MultiSound.Play(new MultiSound.Sound[]
{
new MultiSound.Sound("count-ins/cowbell", eventCaller.currentEntity.beat),
new MultiSound.Sound("count-ins/cowbell", eventCaller.currentEntity.beat + 1f),
new MultiSound.Sound("count-ins/cowbell", eventCaller.currentEntity.beat + 2f),
new MultiSound.Sound("count-ins/cowbell", eventCaller.currentEntity.beat + 3f)
}, false);
}, 4f),
new GameAction("8 beat count-in", delegate
{
MultiSound.Play(new MultiSound.Sound[]
{
new MultiSound.Sound("count-ins/one1", eventCaller.currentEntity.beat),
new MultiSound.Sound("count-ins/two1", eventCaller.currentEntity.beat + 2f),
new MultiSound.Sound("count-ins/one1", eventCaller.currentEntity.beat + 4f),
new MultiSound.Sound("count-ins/two1", eventCaller.currentEntity.beat + 5f),
new MultiSound.Sound("count-ins/three1", eventCaller.currentEntity.beat + 6f),
new MultiSound.Sound("count-ins/four1", eventCaller.currentEntity.beat + 7f)
}, false);
}, 8f),
new GameAction("8 beat count-in (alt)", delegate
{
MultiSound.Play(new MultiSound.Sound[]
{
new MultiSound.Sound("count-ins/one2", eventCaller.currentEntity.beat),
new MultiSound.Sound("count-ins/two2", eventCaller.currentEntity.beat + 2f),
new MultiSound.Sound("count-ins/one2", eventCaller.currentEntity.beat + 4f),
new MultiSound.Sound("count-ins/two2", eventCaller.currentEntity.beat + 5f),
new MultiSound.Sound("count-ins/three2", eventCaller.currentEntity.beat + 6f),
new MultiSound.Sound("count-ins/four2", eventCaller.currentEntity.beat + 7f)
}, false);
}, 8f),
new GameAction("8 beat count-in (cowbell)", delegate
{
MultiSound.Play(new MultiSound.Sound[]
{
new MultiSound.Sound("count-ins/cowbell", eventCaller.currentEntity.beat),
new MultiSound.Sound("count-ins/cowbell", eventCaller.currentEntity.beat + 2f),
new MultiSound.Sound("count-ins/cowbell", eventCaller.currentEntity.beat + 4f),
new MultiSound.Sound("count-ins/cowbell", eventCaller.currentEntity.beat + 5f),
new MultiSound.Sound("count-ins/cowbell", eventCaller.currentEntity.beat + 6f),
new MultiSound.Sound("count-ins/cowbell", eventCaller.currentEntity.beat + 7f)
}, false);
}, 8f),
bread2unity BCCAD interpreter setup
2022-02-10 08:13:54 +00:00
new GameAction("cowbell", delegate { Jukebox.PlayOneShot("count-ins/cowbell"); }, 1f),
new GameAction("one", delegate { Jukebox.PlayOneShot("count-ins/one1"); }, 1f),
new GameAction("one (alt)", delegate { Jukebox.PlayOneShot("count-ins/one2"); }, 1f),
new GameAction("two", delegate { Jukebox.PlayOneShot("count-ins/two1"); }, 1f),
new GameAction("two (alt)", delegate { Jukebox.PlayOneShot("count-ins/two2"); }, 1f),
new GameAction("three", delegate { Jukebox.PlayOneShot("count-ins/three1"); }, 1f),
new GameAction("three (alt)", delegate { Jukebox.PlayOneShot("count-ins/three2"); }, 1f),
new GameAction("four", delegate { Jukebox.PlayOneShot("count-ins/four1"); }, 1f),
new GameAction("four (alt)", delegate { Jukebox.PlayOneShot("count-ins/four2"); }, 1f),
new GameAction("and", delegate { Jukebox.PlayOneShot("count-ins/and"); }, 0.5f),
new GameAction("go!", delegate { Jukebox.PlayOneShot("count-ins/go1"); }, 1f),
new GameAction("go! (alt)", delegate { Jukebox.PlayOneShot("count-ins/go2"); }, 1f),
new GameAction("ready!", delegate
Camera flashes (bug associated with fullscreen)
2022-02-08 01:07:03 +00:00
{
Count ins and event selector cleanup
2022-02-03 03:58:08 +00:00
MultiSound.Play(new MultiSound.Sound[]
{
Camera flashes (bug associated with fullscreen)
2022-02-08 01:07:03 +00:00
new MultiSound.Sound("count-ins/ready1", eventCaller.currentEntity.beat),
new MultiSound.Sound("count-ins/ready2", eventCaller.currentEntity.beat + 1f),
Count ins and event selector cleanup
2022-02-03 03:58:08 +00:00
}, false);
}, 2f),
}),
new Minigame("forkLifter", "Fork Lifter", "FFFFFF", false, false, new List<GameAction>()
Buggy timeline object resizing
2022-01-17 19:23:18 +00:00
{
bread2unity BCCAD interpreter setup
2022-02-10 08:13:54 +00:00
new GameAction("pea", delegate { ForkLifter.instance.Flick(eventCaller.currentEntity.beat, 0); }, 3),
new GameAction("topbun", delegate { ForkLifter.instance.Flick(eventCaller.currentEntity.beat, 1); }, 3),
new GameAction("burger", delegate { ForkLifter.instance.Flick(eventCaller.currentEntity.beat, 2); }, 3),
new GameAction("bottombun", delegate { ForkLifter.instance.Flick(eventCaller.currentEntity.beat, 3); }, 3),
new GameAction("prepare", delegate { ForkLifter.instance.ForkLifterHand.Prepare(); }, 0.5f),
new GameAction("gulp", delegate { ForkLifterPlayer.instance.Eat(); }),
new GameAction("sigh", delegate { Jukebox.PlayOneShot("sigh"); })
Buggy timeline object resizing
2022-01-17 19:23:18 +00:00
}),
Count ins and event selector cleanup
2022-02-03 03:58:08 +00:00
new Minigame("clappyTrio", "The Clappy Trio", "29E7FF", false, false, new List<GameAction>()
Buggy timeline object resizing
2022-01-17 19:23:18 +00:00
{
bread2unity BCCAD interpreter setup
2022-02-10 08:13:54 +00:00
new GameAction("clap", delegate { ClappyTrio.instance.Clap(eventCaller.currentEntity.beat, eventCaller.currentEntity.length); }, 3, true),
new GameAction("bop", delegate { ClappyTrio.instance.Bop(eventCaller.currentEntity.beat); } ),
new GameAction("prepare", delegate { ClappyTrio.instance.Prepare(0); } ),
new GameAction("prepare_alt", delegate { ClappyTrio.instance.Prepare(3); } ),
Buggy timeline object resizing
2022-01-17 19:23:18 +00:00
}),
Count ins and event selector cleanup
2022-02-03 03:58:08 +00:00
new Minigame("spaceball", "Spaceball", "00A518", false, false, new List<GameAction>()
Buggy timeline object resizing
2022-01-17 19:23:18 +00:00
{
bread2unity BCCAD interpreter setup
2022-02-10 08:13:54 +00:00
new GameAction("shoot", delegate { Spaceball.instance.Shoot(eventCaller.currentEntity.beat, false, eventCaller.currentEntity.type); }, 2, false),
new GameAction("shootHigh", delegate { Spaceball.instance.Shoot(eventCaller.currentEntity.beat, true, eventCaller.currentEntity.type); }, 3),
new GameAction("costume", delegate { Spaceball.instance.Costume(eventCaller.currentEntity.type); }, 1f, false, new List<Param>()
Camera flashes (bug associated with fullscreen)
2022-02-08 01:07:03 +00:00
{
Editor: General enum property support. Hex input field functionality for color picker.
2022-02-20 13:31:55 +00:00
new Param("type", Spaceball.CostumeType.Standard, "Type")
Camera flashes (bug associated with fullscreen)
2022-02-08 01:07:03 +00:00
} ),
bread2unity BCCAD interpreter setup
2022-02-10 08:13:54 +00:00
new GameAction("alien", delegate { Spaceball.instance.alien.Show(eventCaller.currentEntity.beat); } ),
new GameAction("camera", delegate { Spaceball.instance.OverrideCurrentZoom(); }, 4, true, new List<Param>()
Camera flashes (bug associated with fullscreen)
2022-02-08 01:07:03 +00:00
{
new Param("valA", new EntityTypes.Integer(1, 320, 10), "Zoom"),
new Param("ease", EasingFunction.Ease.Linear, "Ease")
} ),
bread2unity BCCAD interpreter setup
2022-02-10 08:13:54 +00:00
new GameAction("prepare dispenser", delegate { Spaceball.instance.PrepareDispenser(); }, 1 ),
Buggy timeline object resizing
2022-01-17 19:23:18 +00:00
}),
Count ins and event selector cleanup
2022-02-03 03:58:08 +00:00
new Minigame("karateman", "Karate Man", "70A8D8", false, false, new List<GameAction>()
Buggy timeline object resizing
2022-01-17 19:23:18 +00:00
{
bread2unity BCCAD interpreter setup
2022-02-10 08:13:54 +00:00
new GameAction("bop", delegate { KarateMan.instance.Bop(eventCaller.currentEntity.beat, eventCaller.currentEntity.length); }, 0.5f, true),
new GameAction("pot", delegate { KarateMan.instance.Shoot(eventCaller.currentEntity.beat, 0); }, 2),
Added Light to the Light Bulb if colour is changed with right click You can now right click on bulb in the editor to change the colour of the light emitted. If the colour is set to black then no light is drawn.
2022-02-26 04:57:18 +00:00
new GameAction("bulb", delegate { var e = eventCaller.currentEntity; KarateMan.instance.Shoot(eventCaller.currentEntity.beat, 1, tint: e.colorA); }, 2, false, new List<Param>()
{
new Param("colorA", Color.white, "Light Bulb Color")
}),
bread2unity BCCAD interpreter setup
2022-02-10 08:13:54 +00:00
new GameAction("rock", delegate { KarateMan.instance.Shoot(eventCaller.currentEntity.beat, 2); }, 2),
new GameAction("ball", delegate { KarateMan.instance.Shoot(eventCaller.currentEntity.beat, 3); }, 2),
new GameAction("kick", delegate { KarateMan.instance.Shoot(eventCaller.currentEntity.beat, 4); }, 4.5f),
new GameAction("combo", delegate { KarateMan.instance.Combo(eventCaller.currentEntity.beat); }, 4f),
new GameAction("hit3", delegate { KarateMan.instance.Hit3(eventCaller.currentEntity.beat); }),
new GameAction("hit4", delegate { KarateMan.instance.Hit4(eventCaller.currentEntity.beat); }),
new GameAction("prepare", delegate { KarateMan.instance.Prepare(eventCaller.currentEntity.beat, eventCaller.currentEntity.length); }, 1f, true),
new GameAction("bgfxon", delegate { KarateMan.instance.BGFXOn(); } ),
new GameAction("bgfxoff", delegate { KarateMan.instance.BGFXOff(); }),
new GameAction("tacobell", delegate { KarateMan.instance.Shoot(eventCaller.currentEntity.beat, 6); }, 2),
Autoplay began
2022-01-23 03:40:53 +00:00
}),
Count ins and event selector cleanup
2022-02-03 03:58:08 +00:00
new Minigame("spaceSoccer", "Space Soccer", "B888F8", false, false, new List<GameAction>()
Autoplay began
2022-01-23 03:40:53 +00:00
{
bread2unity BCCAD interpreter setup
2022-02-10 08:13:54 +00:00
new GameAction("ball dispense", delegate { SpaceSoccer.instance.Dispense(eventCaller.currentEntity.beat); }, 2f),
new GameAction("keep-up", delegate { }, 4f, true),
new GameAction("high kick-toe!", delegate { }, 3f, false, new List<Param>()
Camera flashes (bug associated with fullscreen)
2022-02-08 01:07:03 +00:00
{
Swing variable added to entities.
2022-02-24 14:12:19 +00:00
new Param("swing", new EntityTypes.Float(0, 1), "Swing")
Camera flashes (bug associated with fullscreen)
2022-02-08 01:07:03 +00:00
}),
Tempo change? (Don't update very buggy)
2022-01-28 02:50:57 +00:00
}),
Eh it's playable enough
2022-02-25 04:33:51 +00:00
new Minigame("djSchool", "DJ School", "008c97", false, false, new List<GameAction>()
Tempo change? (Don't update very buggy)
2022-01-28 02:50:57 +00:00
{
bread2unity BCCAD interpreter setup
2022-02-10 08:13:54 +00:00
new GameAction("bop", delegate { DJSchool.instance.Bop(eventCaller.currentEntity.beat, eventCaller.currentEntity.length); }, 0.5f, true),
new GameAction("and stop ooh", delegate { DJSchool.instance.AndStop(eventCaller.currentEntity.beat); }, 2.5f),
new GameAction("break c'mon ooh", delegate { DJSchool.instance.BreakCmon(eventCaller.currentEntity.beat, eventCaller.currentEntity.type); }, 3f, false, new List<Param>()
DJ School extra sfx
2022-02-09 07:46:49 +00:00
{
DJ School: Additional gameplay implementation and tuning.
2022-02-20 17:28:56 +00:00
new Param("type", DJSchool.DJVoice.Standard, "Voice"),
DJ School extra sfx
2022-02-09 07:46:49 +00:00
}),
bread2unity BCCAD interpreter setup
2022-02-10 08:13:54 +00:00
new GameAction("scratch-o hey", delegate { DJSchool.instance.ScratchoHey(eventCaller.currentEntity.beat, eventCaller.currentEntity.type); }, 3f, false, new List<Param>()
DJ School extra sfx
2022-02-09 07:46:49 +00:00
{
DJ School: Additional gameplay implementation and tuning.
2022-02-20 17:28:56 +00:00
new Param("type", DJSchool.DJVoice.Standard, "Voice"),
DJ School extra sfx
2022-02-09 07:46:49 +00:00
}),
DJ School sounds
2022-02-03 02:09:50 +00:00
}),
Built to Scale: Gameplay implemented (missing lots of sfx)
2022-02-16 17:04:28 +00:00
new Minigame("rhythmTweezers", "Rhythm Tweezers", "98b389", false, false, new List<GameAction>()
Rhythm tweezers logic but not really
2022-02-09 03:58:25 +00:00
{
bread2unity BCCAD interpreter setup
2022-02-10 08:13:54 +00:00
new GameAction("start interval", delegate { RhythmTweezers.instance.SetIntervalStart(eventCaller.currentEntity.beat, eventCaller.currentEntity.length); }, 4f, true),
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),
Tweezers: Added vegetable type and properties to "Next Vegetable" event. Added "Change Vegetable" event
2022-02-13 14:02:55 +00:00
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>()
{
Editor: General enum property support. Hex input field functionality for color picker.
2022-02-20 13:31:55 +00:00
new Param("type", RhythmTweezers.VegetableType.Onion, "Type"),
Tweezers: Added vegetable type and properties to "Next Vegetable" event. Added "Change Vegetable" event
2022-02-13 14:02:55 +00:00
new Param("colorA", RhythmTweezers.defaultOnionColor, "Onion Color"),
new Param("colorB", RhythmTweezers.defaultPotatoColor, "Potato Color")
} ),
Tap Trial: Player tap animation
2022-02-19 21:03:45 +00:00
new GameAction("change vegetable", delegate { var e = eventCaller.currentEntity; RhythmTweezers.instance.ChangeVegetableImmediate(e.type, e.colorA, e.colorB); }, 0.5f, false, new List<Param>()
Tweezers: Added vegetable type and properties to "Next Vegetable" event. Added "Change Vegetable" event
2022-02-13 14:02:55 +00:00
{
Editor: General enum property support. Hex input field functionality for color picker.
2022-02-20 13:31:55 +00:00
new Param("type", RhythmTweezers.VegetableType.Onion, "Type"),
Tweezers: Added vegetable type and properties to "Next Vegetable" event. Added "Change Vegetable" event
2022-02-13 14:02:55 +00:00
new Param("colorA", RhythmTweezers.defaultOnionColor, "Onion Color"),
new Param("colorB", RhythmTweezers.defaultPotatoColor, "Potato Color")
} ),
Tweezers: Functioning gameplay loop + Editor implementation.
2022-02-09 10:29:09 +00:00
new GameAction("set tweezer delay", delegate { RhythmTweezers.instance.tweezerBeatOffset = eventCaller.currentEntity.length; }, 1f, true),
bread2unity BCCAD interpreter setup
2022-02-10 08:13:54 +00:00
new GameAction("reset tweezer delay", delegate { RhythmTweezers.instance.tweezerBeatOffset = 0f; }, 0.5f),
Tap Trial: Player tap animation
2022-02-19 21:03:45 +00:00
new GameAction("set background color", delegate { var e = eventCaller.currentEntity; RhythmTweezers.instance.ChangeBackgroundColor(e.colorA, 0f); }, 0.5f, false, new List<Param>()
BTSDS: Implemented upscale hit graphic. Tweezers: Added background color events.
2022-02-17 12:11:06 +00:00
{
new Param("colorA", RhythmTweezers.defaultBgColor, "Background Color")
} ),
Tap Trial: Player tap animation
2022-02-19 21:03:45 +00:00
new GameAction("fade background color", delegate { var e = eventCaller.currentEntity; RhythmTweezers.instance.FadeBackgroundColor(e.colorA, e.colorB, e.length); }, 1f, true, new List<Param>()
BTSDS: Implemented upscale hit graphic. Tweezers: Added background color events.
2022-02-17 12:11:06 +00:00
{
new Param("colorA", Color.white, "Start Color"),
new Param("colorB", RhythmTweezers.defaultBgColor, "End Color")
} ),
Rhythm tweezers logic but not really
2022-02-09 03:58:25 +00:00
}),
Custom snap interval, but not in the editor (yet)
2022-02-12 01:15:36 +00:00
Editor: Minor minigame info tweaks.
2022-02-23 03:28:27 +00:00
new Minigame("rhythmRally", "Rhythm Rally \n<color=#eb5454>[WIP don't use]</color>", "FFFFFF", true, false, new List<GameAction>()
DJ School sounds
2022-02-03 02:09:50 +00:00
{
Rhythm Rally: Animations baybeeeeeeeeee
2022-02-12 08:12:12 +00:00
new GameAction("bop", delegate { RhythmRally.instance.Bop(eventCaller.currentEntity.beat, eventCaller.currentEntity.length); }, 0.5f, true),
Rhythm Rally: Whistle separated from "toss ball" event and added to "whistle" event
2022-02-23 03:34:11 +00:00
new GameAction("whistle", delegate { RhythmRally.instance.PlayWhistle(); }, 0.5f),
Rhythm Rally: Added "toss ball" action. Paddler now also tosses ball when you miss.
2022-02-22 06:43:24 +00:00
new GameAction("toss ball", delegate { RhythmRally.instance.Toss(eventCaller.currentEntity.beat, eventCaller.currentEntity.length, 6f, true); }, 2f),
Rhythm Rally: Basic gameplay setup
2022-02-14 08:53:58 +00:00
new GameAction("rally", delegate { RhythmRally.instance.Serve(eventCaller.currentEntity.beat, RhythmRally.RallySpeed.Normal); }, 4f, true),
Tap Trial: Player tap animation
2022-02-19 21:03:45 +00:00
new GameAction("slow rally", delegate { RhythmRally.instance.Serve(eventCaller.currentEntity.beat, RhythmRally.RallySpeed.Slow); }, 8f, true),
new GameAction("fast rally", delegate { RhythmRally.instance.PrepareFastRally(eventCaller.currentEntity.beat, RhythmRally.RallySpeed.Fast); }, 6f),
new GameAction("superfast rally", delegate { RhythmRally.instance.PrepareFastRally(eventCaller.currentEntity.beat, RhythmRally.RallySpeed.SuperFast); }, 12f),
new GameAction("pose", delegate { RhythmRally.instance.Pose(); }, 0.5f),
Built to Scale (DS) asset setup
2022-02-15 23:28:08 +00:00
}),
Editor: Minor minigame info tweaks.
2022-02-23 03:28:27 +00:00
new Minigame("builtToScaleDS", "Built To Scale (DS) \n<color=#eb5454>[WIP don't use]</color>", "00BB00", true, false, new List<GameAction>()
Built to Scale (DS) asset setup
2022-02-15 23:28:08 +00:00
{
Built to Scale: Gameplay implemented (missing lots of sfx)
2022-02-16 17:04:28 +00:00
new GameAction("spawn blocks", delegate { }, 1f, true)
Tempo change? (Don't update very buggy)
2022-01-28 02:50:57 +00:00
}),
Editor: Minor minigame info tweaks.
2022-02-23 03:28:27 +00:00
new Minigame("tapTrial", "Tap Trial \n<color=#eb5454>[WIP don't use]</color>", "93ffb3", false, false, new List<GameAction>()
Tempo change? (Don't update very buggy)
2022-01-28 02:50:57 +00:00
{
Tap Trial: Player tap animation
2022-02-19 21:03:45 +00:00
new GameAction("tap", delegate { TapTrial.instance.Tap(eventCaller.currentEntity.beat); }, 1.5f, false),
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 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),
Tempo change? (Don't update very buggy)
2022-01-28 02:50:57 +00:00
}),
Some tap trial setup
2022-02-19 18:51:46 +00:00
/*new Minigame("spaceDance", "Space Dance", "B888F8", new List<GameAction>()
Tempo change? (Don't update very buggy)
2022-01-28 02:50:57 +00:00
{
Event properties wouldn't update when calling multiple events at once. (FIXED)
2022-01-31 04:59:15 +00:00
}),
new Minigame("sneakySpirits", "Sneaky Spirits", "B888F8", new List<GameAction>()
{
}),
new Minigame("munchyMonk", "Munchy Monk", "B888F8", new List<GameAction>()
{
}),
new Minigame("airRally", "Air Rally", "B888F8", new List<GameAction>()
{
}),
new Minigame("ringside", "Ringside", "B888F8", new List<GameAction>()
{
}),
new Minigame("workingDough", "Working Dough", "B888F8", new List<GameAction>()
{
Tempo change? (Don't update very buggy)
2022-01-28 02:50:57 +00:00
})*/
Buggy timeline object resizing
2022-01-17 19:23:18 +00:00
};
}
}
}
Reference in a new issue Copy permalink