81384fe7fb
* Integration of Jukebox Library (#451) * add Jukebox library todo: - saving / loading of new format - inferrence of unknown data like past versions - move the temporary float casts to proper use of double - make sound related functions take double for timing - inform people that the Jukebox sound player was renamed to SoundByte lol * make sound, input scheduling, and super curve use double precision * successfully load charts * editor works again v1 riqs can be saved and loaded * first tempo and volume markers are unmovable fix loading of charts' easing values * use gsync / freesync * update Jukebox refs to SoundByte * game events use double part 1 Air Rally - Glee Club converted * don't load song if chart load fails * finish conversion of all minigames * remove editor waveform toggle * timeline now respects added song offset length clear cache files on app close prepped notes for dsp sync * update timeline length when offset changed * update to latest Jukebox * make error panel object in global game manager * improve conductor music scheduling * added error message box fix first game events sometimes not playing * a lot * munchy monk input + mustache fixes * fork lifter and pajama party bopping * meat grinder miss bop fix * cloud monkey Real * marching orders Go! was broken * force march doesn't break when it's too early from a game switch * you can use the March! block without the marching now * convert float to double and all that * editor fixes (#459) * ditch loading dialog doesn't show up when it's supposed to * format song offset in editor * remove VorbisPlugin * Update Editor.cs * add updater for marching orders turn * make base datamodels for special entity reading (#463) * make base datamodels for special entity reading * fix crop stomp breaking when no game switch or remix end is set * fix save shortcut fix loading charts with no music * don't infer track when importing a v0 riq from another program * You can now place inputs on top of pass turn for rhythm tweezers * Rockers can do it too now * Some new curves * Converted everything to new curves and made playerballs handle themselves input-wise * working dough converted, need to fix eveerything though * ball transporter anims for pass turn * update Jukebox to latest version fixes for inferred entity loading * new sounds * OnSpawnBall reimplemented * Proper inactive handling now * gandw on balls has been added * Rhythm tweezers pass turn now works like working dough * modernised rockers pass turn * Fixed small balls not working in working dough * Fixed weird curve stuff on game switch in working dough * let play mode start if no song file is loaded fix issue with loading large audio files * add "updater" for the old marching entity --------- Co-authored-by: AstrlJelly <bdlawson115@gmail.com> Co-authored-by: Rapandrasmus <78219215+Rapandrasmus@users.noreply.github.com>
584 lines
23 KiB
C#
584 lines
23 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using System;
|
|
using Starpelly;
|
|
using DG.Tweening;
|
|
|
|
using HeavenStudio.Util;
|
|
|
|
namespace HeavenStudio.Games.Loaders
|
|
{
|
|
using static Minigames;
|
|
public static class AgbHairLoader
|
|
{
|
|
public static Minigame AddGame(EventCaller eventCaller) {
|
|
return new Minigame("rhythmTweezers", "Rhythm Tweezers", "a14fa1", false, false, new List<GameAction>()
|
|
{
|
|
new GameAction("start interval", "Start Interval")
|
|
{
|
|
function = delegate { RhythmTweezers.instance.SetIntervalStart(eventCaller.currentEntity.beat, eventCaller.currentEntity.length); },
|
|
defaultLength = 4f,
|
|
resizable = true,
|
|
priority = 1,
|
|
inactiveFunction = delegate { RhythmTweezers.InactiveInterval(eventCaller.currentEntity.beat, eventCaller.currentEntity.length); }
|
|
},
|
|
new GameAction("short hair", "Short Hair")
|
|
{
|
|
inactiveFunction = delegate { RhythmTweezers.SpawnHairInactive(eventCaller.currentEntity.beat); },
|
|
function = delegate { RhythmTweezers.instance.SpawnHair(eventCaller.currentEntity.beat); },
|
|
defaultLength = 0.5f
|
|
},
|
|
new GameAction("long hair", "Curly Hair")
|
|
{
|
|
inactiveFunction = delegate { RhythmTweezers.SpawnLongHairInactive(eventCaller.currentEntity.beat); },
|
|
function = delegate { RhythmTweezers.instance.SpawnLongHair(eventCaller.currentEntity.beat); },
|
|
defaultLength = 0.5f
|
|
},
|
|
new GameAction("passTurn", "Pass Turn")
|
|
{
|
|
preFunction = delegate { var e = eventCaller.currentEntity; RhythmTweezers.PrePassTurn(e.beat); },
|
|
},
|
|
new GameAction("next vegetable", "Swap Vegetable")
|
|
{
|
|
function = delegate
|
|
{
|
|
var e = eventCaller.currentEntity;
|
|
if (!e["instant"]) RhythmTweezers.instance.NextVegetable(e.beat, e["type"], e["colorA"], e["colorB"]);
|
|
else 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 Param("instant", false, "Instant", "Instantly change vegetable?")
|
|
},
|
|
priority = 3
|
|
},
|
|
new GameAction("noPeek", "No Peeking Sign")
|
|
{
|
|
preFunction = delegate { var e = eventCaller.currentEntity; RhythmTweezers.PreNoPeeking(e.beat, e.length, e["type"]); },
|
|
defaultLength = 4f,
|
|
resizable = true,
|
|
parameters = new List<Param>()
|
|
{
|
|
new Param("type", RhythmTweezers.NoPeekSignType.Full, "Sign Type", "Which sign will be used?")
|
|
}
|
|
},
|
|
new GameAction("fade background color", "Background Fade")
|
|
{
|
|
function = delegate
|
|
{
|
|
var e = eventCaller.currentEntity;
|
|
if (e["instant"])
|
|
{
|
|
RhythmTweezers.instance.ChangeBackgroundColor(e["colorA"], 0f);
|
|
}
|
|
else
|
|
{
|
|
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"),
|
|
new Param("instant", false, "Instant", "Instantly change color to start color?")
|
|
}
|
|
},
|
|
new GameAction("altSmile", "Use Alt Smile")
|
|
{
|
|
function = delegate
|
|
{
|
|
RhythmTweezers.instance.VegetableAnimator.SetBool("UseAltSmile", !RhythmTweezers.instance.VegetableAnimator.GetBool("UseAltSmile"));
|
|
},
|
|
defaultLength = 0.5f
|
|
},
|
|
//backwards compatibility
|
|
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")
|
|
},
|
|
hidden = true,
|
|
},
|
|
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")
|
|
},
|
|
hidden = true
|
|
},
|
|
},
|
|
new List<string>() {"agb", "repeat"},
|
|
"agbhair", "en",
|
|
new List<string>() {}
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
namespace HeavenStudio.Games
|
|
{
|
|
using Scripts_RhythmTweezers;
|
|
|
|
public class RhythmTweezers : Minigame
|
|
{
|
|
public enum VegetableType
|
|
{
|
|
Onion,
|
|
Potato
|
|
}
|
|
|
|
public enum NoPeekSignType
|
|
{
|
|
Full,
|
|
HalfRight,
|
|
HalfLeft
|
|
}
|
|
|
|
private struct QueuedPeek
|
|
{
|
|
public double beat;
|
|
public float length;
|
|
public int type;
|
|
}
|
|
|
|
[Header("References")]
|
|
public Transform VegetableHolder;
|
|
public SpriteRenderer Vegetable;
|
|
public SpriteRenderer VegetableDupe;
|
|
public Animator VegetableAnimator;
|
|
public SpriteRenderer bg;
|
|
public Tweezers Tweezers;
|
|
public GameObject hairBase;
|
|
public GameObject longHairBase;
|
|
public GameObject pluckedHairBase;
|
|
[SerializeField] NoPeekingSign noPeekingRef;
|
|
|
|
public GameObject HairsHolder;
|
|
public GameObject DroppedHairsHolder;
|
|
[NonSerialized] public int hairsLeft = 0;
|
|
|
|
[Header("Variables")]
|
|
private double passTurnBeat;
|
|
private double passTurnEndBeat = 2;
|
|
private static List<QueuedPeek> queuedPeeks = new List<QueuedPeek>();
|
|
|
|
[Header("Sprites")]
|
|
public Sprite pluckedHairSprite;
|
|
public Sprite missedHairSprite;
|
|
public Sprite onionSprite;
|
|
public Sprite potatoSprite;
|
|
|
|
[NonSerialized] public int eyeSize = 0;
|
|
|
|
Tween transitionTween;
|
|
bool transitioning = false;
|
|
Tween bgColorTween;
|
|
|
|
private static Color _defaultOnionColor;
|
|
public static Color defaultOnionColor
|
|
{
|
|
get
|
|
{
|
|
ColorUtility.TryParseHtmlString("#C89600", out _defaultOnionColor);
|
|
return _defaultOnionColor;
|
|
}
|
|
}
|
|
|
|
private static Color _defaultPotatoColor;
|
|
public static Color defaultPotatoColor
|
|
{
|
|
get
|
|
{
|
|
ColorUtility.TryParseHtmlString("#FFDC00", out _defaultPotatoColor);
|
|
return _defaultPotatoColor;
|
|
}
|
|
}
|
|
|
|
private static Color _defaultBgColor;
|
|
public static Color defaultBgColor
|
|
{
|
|
get
|
|
{
|
|
ColorUtility.TryParseHtmlString("#A14FA1", out _defaultBgColor);
|
|
return _defaultBgColor;
|
|
}
|
|
}
|
|
|
|
public static RhythmTweezers instance { get; set; }
|
|
private static CallAndResponseHandler crHandlerInstance;
|
|
|
|
private List<Hair> spawnedHairs = new List<Hair>();
|
|
private List<LongHair> spawnedLongs = new List<LongHair>();
|
|
|
|
private static List<double> passedTurns = new();
|
|
|
|
private void Awake()
|
|
{
|
|
instance = this;
|
|
if (crHandlerInstance == null)
|
|
{
|
|
crHandlerInstance = new CallAndResponseHandler(4);
|
|
}
|
|
if (crHandlerInstance.queuedEvents.Count > 0)
|
|
{
|
|
foreach (var crEvent in crHandlerInstance.queuedEvents)
|
|
{
|
|
if (crEvent.tag == "Hair")
|
|
{
|
|
Hair hair = Instantiate(hairBase, HairsHolder.transform).GetComponent<Hair>();
|
|
spawnedHairs.Add(hair);
|
|
hair.gameObject.SetActive(true);
|
|
hair.GetComponent<Animator>().Play("SmallAppear", 0, 1);
|
|
float rot = -58f + 116 * Mathp.Normalize((float)crEvent.relativeBeat, 0, crHandlerInstance.intervalLength - 1);
|
|
hair.transform.eulerAngles = new Vector3(0, 0, rot);
|
|
hair.createBeat = crEvent.beat;
|
|
}
|
|
else if (crEvent.tag == "Long")
|
|
{
|
|
LongHair hair = Instantiate(longHairBase, HairsHolder.transform).GetComponent<LongHair>();
|
|
spawnedLongs.Add(hair);
|
|
hair.gameObject.SetActive(true);
|
|
hair.GetComponent<Animator>().Play("LongAppear", 0, 1);
|
|
float rot = -58f + 116 * Mathp.Normalize((float)crEvent.relativeBeat, 0, crHandlerInstance.intervalLength - 1);
|
|
hair.transform.eulerAngles = new Vector3(0, 0, rot);
|
|
hair.createBeat = crEvent.beat;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void OnDestroy()
|
|
{
|
|
if (crHandlerInstance != null && !Conductor.instance.isPlaying)
|
|
{
|
|
crHandlerInstance = null;
|
|
}
|
|
foreach (var evt in scheduledInputs)
|
|
{
|
|
evt.Disable();
|
|
}
|
|
}
|
|
|
|
public static void SpawnHairInactive(double beat)
|
|
{
|
|
if (crHandlerInstance == null)
|
|
{
|
|
crHandlerInstance = new CallAndResponseHandler(4);
|
|
}
|
|
if (crHandlerInstance.queuedEvents.Count > 0 && crHandlerInstance.queuedEvents.Find(x => x.beat == beat || (beat >= x.beat && beat <= x.beat + x.length)) != null) return;
|
|
crHandlerInstance.AddEvent(beat, 0, "Hair");
|
|
}
|
|
|
|
public static void SpawnLongHairInactive(double beat)
|
|
{
|
|
if (crHandlerInstance == null)
|
|
{
|
|
crHandlerInstance = new CallAndResponseHandler(4);
|
|
}
|
|
if (crHandlerInstance.queuedEvents.Count > 0 && crHandlerInstance.queuedEvents.Find(x => x.beat == beat || (beat >= x.beat && beat <= x.beat + x.length)) != null) return;
|
|
crHandlerInstance.AddEvent(beat, 0.5f, "Long");
|
|
}
|
|
|
|
public void SpawnHair(double beat)
|
|
{
|
|
if (crHandlerInstance.queuedEvents.Count > 0 && crHandlerInstance.queuedEvents.Find(x => x.beat == beat || (beat >= x.beat && beat <= x.beat + x.length)) != null) return;
|
|
// End transition early if the next hair is a lil early.
|
|
StopTransitionIfActive();
|
|
|
|
crHandlerInstance.AddEvent(beat, 0, "Hair");
|
|
|
|
SoundByte.PlayOneShotGame("rhythmTweezers/shortAppear", beat);
|
|
Hair hair = Instantiate(hairBase, HairsHolder.transform).GetComponent<Hair>();
|
|
spawnedHairs.Add(hair);
|
|
hair.gameObject.SetActive(true);
|
|
hair.GetComponent<Animator>().Play("SmallAppear", 0, 0);
|
|
|
|
float rot = -58f + 116 * crHandlerInstance.GetIntervalProgressFromBeat(beat, 1);
|
|
hair.transform.eulerAngles = new Vector3(0, 0, rot);
|
|
hair.createBeat = beat;
|
|
}
|
|
|
|
public void SpawnLongHair(double beat)
|
|
{
|
|
if (crHandlerInstance.queuedEvents.Count > 0 && crHandlerInstance.queuedEvents.Find(x => x.beat == beat || (beat >= x.beat && beat <= x.beat + x.length)) != null) return;
|
|
StopTransitionIfActive();
|
|
|
|
crHandlerInstance.AddEvent(beat, 0.5f, "Long");
|
|
|
|
SoundByte.PlayOneShotGame("rhythmTweezers/longAppear", beat);
|
|
LongHair hair = Instantiate(longHairBase, HairsHolder.transform).GetComponent<LongHair>();
|
|
spawnedLongs.Add(hair);
|
|
hair.gameObject.SetActive(true);
|
|
hair.GetComponent<Animator>().Play("LongAppear", 0, 0);
|
|
|
|
float rot = -58f + 116 * crHandlerInstance.GetIntervalProgressFromBeat(beat, 1);
|
|
hair.transform.eulerAngles = new Vector3(0, 0, rot);
|
|
hair.createBeat = beat;
|
|
}
|
|
|
|
public void SetIntervalStart(double beat, float interval = 4f)
|
|
{
|
|
StopTransitionIfActive();
|
|
hairsLeft = 0;
|
|
eyeSize = 0;
|
|
crHandlerInstance.StartInterval(beat, interval);
|
|
}
|
|
|
|
public static void InactiveInterval(double beat, float interval)
|
|
{
|
|
if (crHandlerInstance == null)
|
|
{
|
|
crHandlerInstance = new CallAndResponseHandler(4);
|
|
}
|
|
crHandlerInstance.StartInterval(beat, interval);
|
|
}
|
|
|
|
public void PassTurn(double beat)
|
|
{
|
|
if (crHandlerInstance.queuedEvents.Count > 0)
|
|
{
|
|
BeatAction.New(instance.gameObject, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beat - 1, delegate
|
|
{
|
|
hairsLeft = crHandlerInstance.queuedEvents.Count;
|
|
foreach (var crEvent in crHandlerInstance.queuedEvents)
|
|
{
|
|
if (crEvent.tag == "Hair")
|
|
{
|
|
Hair hairToInput = spawnedHairs.Find(x => x.createBeat == crEvent.beat);
|
|
hairToInput.StartInput(beat, crEvent.relativeBeat);
|
|
}
|
|
else if (crEvent.tag == "Long")
|
|
{
|
|
LongHair hairToInput = spawnedLongs.Find(x => x.createBeat == crEvent.beat);
|
|
hairToInput.StartInput(beat, crEvent.relativeBeat);
|
|
}
|
|
}
|
|
crHandlerInstance.queuedEvents.Clear();
|
|
}),
|
|
new BeatAction.Action(beat, delegate
|
|
{
|
|
if (crHandlerInstance.queuedEvents.Count > 0)
|
|
{
|
|
hairsLeft += crHandlerInstance.queuedEvents.Count;
|
|
foreach (var crEvent in crHandlerInstance.queuedEvents)
|
|
{
|
|
if (crEvent.tag == "Hair")
|
|
{
|
|
Hair hairToInput = spawnedHairs.Find(x => x.createBeat == crEvent.beat);
|
|
hairToInput.StartInput(beat, crEvent.relativeBeat);
|
|
}
|
|
else if (crEvent.tag == "Long")
|
|
{
|
|
LongHair hairToInput = spawnedLongs.Find(x => x.createBeat == crEvent.beat);
|
|
hairToInput.StartInput(beat, crEvent.relativeBeat);
|
|
}
|
|
}
|
|
crHandlerInstance.queuedEvents.Clear();
|
|
}
|
|
})
|
|
});
|
|
}
|
|
}
|
|
|
|
public static void PrePassTurn(double beat)
|
|
{
|
|
if (GameManager.instance.currentGame == "rhythmTweezers")
|
|
{
|
|
instance.SetPassTurnValues(beat);
|
|
instance.PassTurn(beat);
|
|
}
|
|
else
|
|
{
|
|
passedTurns.Add(beat);
|
|
}
|
|
}
|
|
|
|
private void SetPassTurnValues(double startBeat)
|
|
{
|
|
if (crHandlerInstance.intervalLength <= 0) return;
|
|
passTurnBeat = startBeat - 1;
|
|
passTurnEndBeat = startBeat + crHandlerInstance.intervalLength;
|
|
}
|
|
|
|
const float vegDupeOffset = 16.7f;
|
|
public void NextVegetable(double beat, int type, Color onionColor, Color potatoColor)
|
|
{
|
|
transitioning = true;
|
|
|
|
SoundByte.PlayOneShotGame("rhythmTweezers/register", beat);
|
|
|
|
Sprite nextVeggieSprite = type == 0 ? onionSprite : potatoSprite;
|
|
Color nextColor = type == 0 ? onionColor : potatoColor;
|
|
|
|
VegetableDupe.sprite = nextVeggieSprite;
|
|
VegetableDupe.color = nextColor;
|
|
|
|
// Move both vegetables to the left by vegDupeOffset, then reset their positions.
|
|
// On position reset, reset state of core vegetable.
|
|
transitionTween = VegetableHolder.DOLocalMoveX(-vegDupeOffset, Conductor.instance.secPerBeat * 0.5f / Conductor.instance.musicSource.pitch)
|
|
.OnComplete(() => {
|
|
|
|
var holderPos = VegetableHolder.localPosition;
|
|
VegetableHolder.localPosition = new Vector3(0f, holderPos.y, holderPos.z);
|
|
|
|
Vegetable.sprite = nextVeggieSprite;
|
|
Vegetable.color = nextColor;
|
|
|
|
ResetVegetable();
|
|
transitioning = false;
|
|
|
|
}).SetEase(Ease.InOutSine);
|
|
}
|
|
|
|
public void ChangeVegetableImmediate(int type, Color onionColor, Color potatoColor)
|
|
{
|
|
StopTransitionIfActive();
|
|
|
|
Sprite newSprite = type == 0 ? onionSprite : potatoSprite;
|
|
Color newColor = type == 0 ? onionColor : potatoColor;
|
|
|
|
Vegetable.sprite = newSprite;
|
|
Vegetable.color = newColor;
|
|
VegetableDupe.sprite = newSprite;
|
|
VegetableDupe.color = newColor;
|
|
}
|
|
|
|
public void ChangeBackgroundColor(Color color, float beats)
|
|
{
|
|
var seconds = Conductor.instance.secPerBeat * beats;
|
|
|
|
if (bgColorTween != null)
|
|
bgColorTween.Kill(true);
|
|
|
|
if (seconds == 0)
|
|
{
|
|
bg.color = color;
|
|
}
|
|
else
|
|
{
|
|
bgColorTween = bg.DOColor(color, seconds);
|
|
}
|
|
}
|
|
|
|
public void FadeBackgroundColor(Color start, Color end, float beats)
|
|
{
|
|
ChangeBackgroundColor(start, 0f);
|
|
ChangeBackgroundColor(end, beats);
|
|
}
|
|
|
|
public static void PreNoPeeking(double beat, float length, int type)
|
|
{
|
|
if (GameManager.instance.currentGame == "rhythmTweezers")
|
|
{
|
|
instance.NoPeeking(beat, length, type);
|
|
}
|
|
else
|
|
{
|
|
queuedPeeks.Add(new QueuedPeek()
|
|
{
|
|
beat = beat,
|
|
length = length,
|
|
type = type
|
|
});
|
|
}
|
|
}
|
|
|
|
public void NoPeeking(double beat, float length, int type)
|
|
{
|
|
NoPeekingSign spawnedNoPeekingSign = Instantiate(noPeekingRef, transform);
|
|
spawnedNoPeekingSign.gameObject.SetActive(true);
|
|
spawnedNoPeekingSign.Init(beat, length, type);
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
if (Conductor.instance.isPlaying && !Conductor.instance.isPaused)
|
|
{
|
|
if (passedTurns.Count > 0)
|
|
{
|
|
foreach (var turn in passedTurns)
|
|
{
|
|
SetPassTurnValues(turn);
|
|
PassTurn(turn);
|
|
}
|
|
passedTurns.Clear();
|
|
}
|
|
if (queuedPeeks.Count > 0)
|
|
{
|
|
foreach (var peek in queuedPeeks)
|
|
{
|
|
NoPeeking(peek.beat, peek.length, peek.type);
|
|
}
|
|
queuedPeeks.Clear();
|
|
}
|
|
}
|
|
}
|
|
|
|
private void LateUpdate()
|
|
{
|
|
// Set tweezer angle.
|
|
var tweezerAngle = -180f;
|
|
|
|
var tweezerTime = Conductor.instance.songPositionInBeats;
|
|
var unclampedAngle = -58f + 116 * Mathp.Normalize(tweezerTime, (float)passTurnBeat + 1f, (float)passTurnEndBeat - 1f);
|
|
tweezerAngle = Mathf.Clamp(unclampedAngle, -180f, 180f);
|
|
|
|
Tweezers.transform.eulerAngles = new Vector3(0, 0, tweezerAngle);
|
|
|
|
// Set tweezer to follow vegetable.
|
|
var currentTweezerPos = Tweezers.transform.localPosition;
|
|
var vegetablePos = Vegetable.transform.localPosition;
|
|
var vegetableHolderPos = VegetableHolder.transform.localPosition;
|
|
Tweezers.transform.localPosition = new Vector3(vegetableHolderPos.x, vegetablePos.y + 1f, currentTweezerPos.z);
|
|
}
|
|
|
|
private void ResetVegetable()
|
|
{
|
|
// If the tweezers happen to be holding a hair, drop it immediately so it can be destroyed below.
|
|
Tweezers.DropHeldHair();
|
|
|
|
foreach (Transform t in HairsHolder.transform)
|
|
{
|
|
GameObject.Destroy(t.gameObject);
|
|
}
|
|
|
|
foreach (Transform t in DroppedHairsHolder.transform)
|
|
{
|
|
GameObject.Destroy(t.gameObject);
|
|
}
|
|
|
|
VegetableAnimator.Play("Idle", 0, 0);
|
|
|
|
eyeSize = 0;
|
|
}
|
|
|
|
private void StopTransitionIfActive()
|
|
{
|
|
if (transitioning)
|
|
{
|
|
if (transitionTween != null)
|
|
{
|
|
transitionTween.Complete(true);
|
|
transitionTween.Kill();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|