etc/HeavenStudioPlus
0
0
Fork 0
mirror of https://github.com/RHeavenStudioPlus/HeavenStudioPlus.git synced 2024-11-14 05:35:08 +00:00
Code Issues Projects Releases Packages Wiki Activity
HeavenStudioPlus/Assets/Scripts/Minigames.cs

378 lines
26 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;
Rhythm Rally Camera Event Rotate the camera with different easing functions and the option to add/remove from current rotation.
2022-02-28 19:31:28 +00:00
using DG.Tweening;
Buggy timeline object resizing
2022-01-17 19:23:18 +00:00
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;
Crop Stomp: He go
2022-02-28 05:11:18 +00:00
using RhythmHeavenMania.Games.CropStomp;
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(); }),
Fixed the sigh sfx in Fork Lifter
2022-02-26 07:57:09 +00:00
new GameAction("sigh", delegate { Jukebox.PlayOneShot("games/forkLifter/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),
Implemented proper sprite, flickering, and dropdown menu There's now a "type" dropdown menu that allows you to choose between "Normal", "Yellow", "Blue", and "Custom". Custom will use the color specified in the Custom Color field
2022-02-26 06:31:35 +00:00
new GameAction("bulb", delegate {
var e = eventCaller.currentEntity;
var c = KarateMan.instance.LightBulbColors[e.type];
Code Clean Up
2022-02-26 18:57:09 +00:00
if(e.type == (int)KarateMan.LightBulbType.Custom) c = e.colorA;
KarateMan.instance.Shoot(e.beat, 1, tint: c);
Implemented proper sprite, flickering, and dropdown menu There's now a "type" dropdown menu that allows you to choose between "Normal", "Yellow", "Blue", and "Custom". Custom will use the color specified in the Custom Color field
2022-02-26 06:31:35 +00:00
}, 2, false, new List<Param>()
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
{
Implemented proper sprite, flickering, and dropdown menu There's now a "type" dropdown menu that allows you to choose between "Normal", "Yellow", "Blue", and "Custom". Custom will use the color specified in the Custom Color field
2022-02-26 06:31:35 +00:00
new Param("type", KarateMan.LightBulbType.Normal, "Type"),
new Param("colorA", new Color(), "Custom Color")
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
}),
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(); }),
Added "set background color" to Karate Man. Seemingly stops working after a few background changes but works between game changes
2022-02-26 18:27:02 +00:00
new GameAction("set background color", delegate {
var e = eventCaller.currentEntity;
var c = KarateMan.instance.BackgroundColors[e.type];
Code Clean Up
2022-02-26 18:57:09 +00:00
if(e.type == (int)KarateMan.BackgroundType.Custom) c = e.colorA;
Added custom shadow colours And specific shadow colours for preset background types
2022-02-27 17:02:46 +00:00
KarateMan.instance.SetBackgroundColor(e.type, e.type2, c, e.colorB);
Make length of bgcolor event match rhythm tweezers
2022-02-27 18:54:46 +00:00
}, 0.5f, false, new List<Param>()
Added "set background color" to Karate Man. Seemingly stops working after a few background changes but works between game changes
2022-02-26 18:27:02 +00:00
{
Added custom shadow colours And specific shadow colours for preset background types
2022-02-27 17:02:46 +00:00
new Param("type", KarateMan.BackgroundType.Yellow, "Background Type"),
new Param("type2", KarateMan.ShadowType.Tinted, "Shadow Type"),
new Param("colorA", new Color(), "Custom Background Color"),
new Param("colorB", new Color(), "Custom Shadow Color")
Added "set background color" to Karate Man. Seemingly stops working after a few background changes but works between game changes
2022-02-26 18:27:02 +00:00
}),
bread2unity BCCAD interpreter setup
2022-02-10 08:13:54 +00:00
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
{
Refactored Space Soccer scripts most of the refactoring is in the ball script, and the changes for the kicker and space soccer scripts are mostly in response to the refactoring.
2022-02-26 07:27:51 +00:00
new Param("swing", new EntityTypes.Float(0, 1, 0.5f), "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),
Rhythm Rally Camera Event Rotate the camera with different easing functions and the option to add/remove from current rotation.
2022-02-28 19:31:28 +00:00
new GameAction("camera", delegate {
var e = eventCaller.currentEntity;
var rotation = new Vector3(0, e.valA, 0);
Added camera zoom
2022-02-28 20:43:32 +00:00
RhythmRally.instance.ChangeCameraAngle(rotation, e.valB, e.length, (Ease)e.type, (RotateMode)e.type2);
Rhythm Rally Camera Event Rotate the camera with different easing functions and the option to add/remove from current rotation.
2022-02-28 19:31:28 +00:00
}, 4, true, new List<Param>() {
new Param("valA", new EntityTypes.Integer(-360, 360, 0), "Angle"),
Added camera zoom
2022-02-28 20:43:32 +00:00
new Param("valB", new EntityTypes.Float(0.5f, 4f, 1), "Zoom"),
Rhythm Rally Camera Event Rotate the camera with different easing functions and the option to add/remove from current rotation.
2022-02-28 19:31:28 +00:00
new Param("type", Ease.Linear, "Ease"),
new Param("type2", RotateMode.Fast, "Rotation Mode")
} ),
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
{
Added Placeholder animations for Tap Trial Added Double Tap and Triple Tap placeholder animations so they can be used in a remix until they're made actually playable.
2022-02-28 00:17:12 +00:00
new GameAction("tap", delegate { TapTrial.instance.Tap(eventCaller.currentEntity.beat); }, 2.0f, false),
Tap Trial: Player tap animation
2022-02-19 21:03:45 +00:00
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
}),
Crop Stomp: He go
2022-02-28 05:11:18 +00:00
new Minigame("cropStomp", "Crop Stomp \n<color=#eb5454>[WIP don't use]</color>", "BFDEA6", false, false, new List<GameAction>()
{
new GameAction("start marching", delegate { CropStomp.instance.StartMarching(eventCaller.currentEntity.beat); }, 0.5f, false),
}),
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