410 lines
15 KiB
C#
410 lines
15 KiB
C#
using DG.Tweening;
|
|
using NaughtyBezierCurves;
|
|
using HeavenStudio.Util;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
using Jukebox;
|
|
|
|
namespace HeavenStudio.Games.Loaders
|
|
{
|
|
using static Minigames;
|
|
public static class NtrCropLoader
|
|
{
|
|
public static Minigame AddGame(EventCaller eventCaller) {
|
|
return new Minigame("cropStomp", "Crop Stomp", "c0f0b8", false, false, new List<GameAction>()
|
|
{
|
|
new GameAction("start marching", "Start Marching")
|
|
{
|
|
function = delegate { CropStomp.instance.StartMarching(eventCaller.currentEntity.beat); },
|
|
defaultLength = 2f,
|
|
inactiveFunction = delegate { CropStomp.MarchInactive(eventCaller.currentEntity.beat); }
|
|
},
|
|
new GameAction("veggies", "Veggies")
|
|
{
|
|
defaultLength = 4f,
|
|
resizable = true
|
|
},
|
|
new GameAction("mole", "Mole")
|
|
{
|
|
preFunction = delegate
|
|
{
|
|
if (eventCaller.currentEntity["mute"]) return;
|
|
CropStomp.MoleSound(eventCaller.currentEntity.beat);
|
|
},
|
|
defaultLength = 2f,
|
|
parameters = new List<Param>()
|
|
{
|
|
new Param("mute", false, "Mute", "Should the mole laugh sound be muted?")
|
|
},
|
|
preFunctionLength = 6
|
|
},
|
|
new GameAction("end", "End")
|
|
{
|
|
parameters = new List<Param>()
|
|
{
|
|
new Param("mute", true, "Mute Humming?")
|
|
}
|
|
},
|
|
new GameAction("plantCollect", "Veggie Collection Values")
|
|
{
|
|
function = delegate { var e = eventCaller.currentEntity;
|
|
CropStomp.instance.SetCollectThresholds(e["threshold"], e["limit"], e["force"], e["forceAmount"]);
|
|
},
|
|
defaultLength = 0.5f,
|
|
parameters = new List<Param>()
|
|
{
|
|
new Param("threshold", new EntityTypes.Integer(1, 80, 8), "Threshold", "For each time the threshold is met a new plant will appear in the veggie bag."),
|
|
new Param("limit", new EntityTypes.Integer(1, 1000, 80), "Limit", "What is the limit for plants collected?"),
|
|
new Param("force", false, "Force Amount of Collected Plants", "", new List<Param.CollapseParam>()
|
|
{
|
|
new Param.CollapseParam((x, _) => (bool)x, new string[] { "forceAmount" })
|
|
}),
|
|
new Param("forceAmount", new EntityTypes.Integer(0, 1000, 0), "Force Amount")
|
|
}
|
|
}
|
|
},
|
|
new List<string>() {"ntr", "keep"},
|
|
"ntrstomp", "en",
|
|
new List<string>() {}
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
namespace HeavenStudio.Games
|
|
{
|
|
using Scripts_CropStomp;
|
|
|
|
public class CropStomp : Minigame
|
|
{
|
|
const float stepDistance = 2.115f;
|
|
//public static float[] moleSoundOffsets = new float[]{ 0.134f, 0.05f, 0.061f };
|
|
|
|
float scrollRate => stepDistance / (Conductor.instance.pitchedSecPerBeat * 2f);
|
|
float grassWidth;
|
|
float dotsWidth = 19.2f;
|
|
|
|
private double newBeat = -1f; // So that marching can happen on beat 0.
|
|
private double marchStartBeat = -1f;
|
|
private double marchEndBeat = double.MaxValue;
|
|
private bool willNotHum = true;
|
|
private double marchOffset;
|
|
private int currentMarchBeat;
|
|
private int stepCount;
|
|
private bool isStepping;
|
|
|
|
private static double inactiveStart = -1f;
|
|
|
|
public bool isMarching => marchStartBeat != -1f;
|
|
|
|
[NonSerialized] public bool isFlicking;
|
|
|
|
public GameObject baseVeggie;
|
|
public GameObject baseMole;
|
|
public Animator legsAnim;
|
|
public Animator bodyAnim;
|
|
public Transform farmerTrans;
|
|
public SpriteRenderer grass;
|
|
public Transform grassTrans;
|
|
public Transform dotsTrans;
|
|
public Transform scrollingHolder;
|
|
public Transform veggieHolder;
|
|
public Farmer farmer;
|
|
public BezierCurve3D pickCurve;
|
|
public BezierCurve3D moleCurve;
|
|
|
|
private Tween shakeTween;
|
|
|
|
public ParticleSystem hitParticle;
|
|
|
|
public static CropStomp instance;
|
|
|
|
public static PlayerInput.InputAction InputAction_Flick =
|
|
new("NtrStompFlick", new int[] { IAEmptyCat, IAFlickCat, IAEmptyCat },
|
|
IA_Empty, IA_TouchFlick, IA_Empty);
|
|
|
|
private void Awake()
|
|
{
|
|
instance = this; // Finding grass sprite width for grass scrolling.
|
|
farmer.Init();
|
|
Sprite sprite = grass.sprite;
|
|
float borderLeft = sprite.rect.xMin + sprite.border.x;
|
|
float borderRight = sprite.rect.xMax - sprite.border.z;
|
|
float borderWidthPixels = borderRight - borderLeft;
|
|
grassWidth = borderWidthPixels / sprite.pixelsPerUnit;
|
|
|
|
legsAnim.Play("LiftFront", 0, 1); // Start with leg up.
|
|
}
|
|
|
|
public override void OnGameSwitch(double beat)
|
|
{
|
|
double startBeat;
|
|
double endBeat = double.MaxValue;
|
|
var entities = GameManager.instance.Beatmap.Entities;
|
|
if (inactiveStart == -1f)
|
|
{
|
|
// Find the beat of the closest "start marching" event.
|
|
var lastMarch = entities.Find(c => c.datamodel == "cropStomp/start marching" && beat <= c.beat);
|
|
startBeat = lastMarch?.beat ?? beat;
|
|
}
|
|
else
|
|
{
|
|
// Find the beat of the next step, assuming marching started at inactiveStart.
|
|
int stepsPassed = 0;
|
|
|
|
while (inactiveStart + (stepsPassed * 2f) < beat)
|
|
{
|
|
stepsPassed++;
|
|
|
|
if (stepsPassed > 1000)
|
|
{
|
|
Debug.Log("Loop broke!");
|
|
return;
|
|
}
|
|
}
|
|
|
|
startBeat = inactiveStart + (stepsPassed * 2f);
|
|
|
|
// Cue the marching proper to begin when applicable.
|
|
BeatAction.New(this, new() { new(startBeat - 0.25f, delegate { StartMarching(startBeat); }) });
|
|
|
|
inactiveStart = -1f;
|
|
}
|
|
|
|
// find out when the next game switch (or remix end) happens
|
|
RiqEntity firstEnd = entities.Find(c => c.datamodel is "gameManager/switchGame/cropStomp" or "gameManager/end" && c.beat > startBeat);
|
|
endBeat = firstEnd?.beat ?? double.MaxValue;
|
|
|
|
// Veggie and mole events.
|
|
List<RiqEntity> vegEvents = entities.FindAll(v => v.datamodel == "cropStomp/veggies");
|
|
List<RiqEntity> moleEvents = entities.FindAll(m => m.datamodel == "cropStomp/mole");
|
|
|
|
// Spawn veggies.
|
|
for (int i = 0; i < vegEvents.Count; i++) {
|
|
var vegBeat = vegEvents[i].beat;
|
|
var vegLength = vegEvents[i].length;
|
|
|
|
// Only consider veggie events that aren't past the start point.
|
|
if (startBeat <= vegBeat + vegLength) {
|
|
int veggiesInEvent = Mathf.CeilToInt(vegLength + 1) / 2;
|
|
|
|
for (int b = 0; b < veggiesInEvent; b++)
|
|
{
|
|
var targetVeggieBeat = vegBeat + (2f * b);
|
|
if (startBeat <= targetVeggieBeat && targetVeggieBeat < endBeat)
|
|
{
|
|
SpawnVeggie(targetVeggieBeat, startBeat, false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Spawn moles.
|
|
for (int i = 0; i < moleEvents.Count; i++) {
|
|
var moleBeat = moleEvents[i].beat;
|
|
|
|
if (startBeat <= moleBeat && moleBeat < endBeat) {
|
|
SpawnVeggie(moleBeat, startBeat, true);
|
|
}
|
|
}
|
|
SetInitTresholds(beat);
|
|
SetMarchEndBeat(beat);
|
|
}
|
|
|
|
public override void OnPlay(double beat)
|
|
{
|
|
OnGameSwitch(beat);
|
|
}
|
|
|
|
private void SetMarchEndBeat(double beat)
|
|
{
|
|
var nextEnd = EventCaller.GetAllInGameManagerList("gameManager", new string[] { "switchGame", "end" }).Find(e => e.beat > beat);
|
|
double nextEndBeat = nextEnd?.beat ?? double.MaxValue;
|
|
|
|
var firstEnd = GameManager.instance.Beatmap.Entities.Find(c => c.datamodel == "cropStomp/end" && c.beat >= beat && c.beat < nextEndBeat);
|
|
if (firstEnd != null) {
|
|
marchEndBeat = firstEnd.beat;
|
|
willNotHum = firstEnd["mute"];
|
|
}
|
|
}
|
|
|
|
public static void MoleSound(double beat)
|
|
{
|
|
MultiSound.Play(new MultiSound.Sound[] {
|
|
new MultiSound.Sound("cropStomp/moleNyeh", beat - 2, offset: 0.134),
|
|
new MultiSound.Sound("cropStomp/moleHeh1", beat - 1.5, offset: 0.05),
|
|
new MultiSound.Sound("cropStomp/moleHeh2", beat - 1, offset: 0.061)
|
|
}, forcePlay: true);
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
var cond = Conductor.instance;
|
|
|
|
if (!cond.isPlaying || !isMarching) return;
|
|
|
|
// Debug.Log(newBeat);
|
|
|
|
bool cameraLocked = cond.songPositionInBeats >= marchEndBeat;
|
|
bool isHumming = !(cameraLocked && willNotHum);
|
|
|
|
if (cond.ReportBeat(ref newBeat, marchOffset, true))
|
|
{
|
|
currentMarchBeat += 1;
|
|
|
|
PlayAnims();
|
|
if (currentMarchBeat % 2 != 0 && isHumming) //step sound
|
|
{
|
|
MultiSound.Play(new MultiSound.Sound[] {new MultiSound.Sound("cropStomp/hmm", newBeat + marchOffset)});
|
|
}
|
|
}
|
|
|
|
if (PlayerInput.GetIsAction(InputAction_BasicRelease) && !IsExpectingInputNow(InputAction_BasicRelease))
|
|
{
|
|
bodyAnim.DoScaledAnimationAsync("Raise", 0.5f);
|
|
}
|
|
if (PlayerInput.GetIsAction(InputAction_Flick) && !IsExpectingInputNow(InputAction_FlickRelease))
|
|
{
|
|
bodyAnim.DoScaledAnimationAsync("Pick", 0.5f);
|
|
}
|
|
|
|
if (cameraLocked) return;
|
|
|
|
// Object scroll.
|
|
var scrollPos = scrollingHolder.localPosition;
|
|
var newScrollX = scrollPos.x + (scrollRate * Time.deltaTime);
|
|
scrollingHolder.localPosition = new Vector3(newScrollX, scrollPos.y, scrollPos.z);
|
|
|
|
// Grass scroll.
|
|
var grassPos = grassTrans.localPosition;
|
|
|
|
var newGrassX = grassPos.x + (scrollRate * Time.deltaTime);
|
|
newGrassX %= grassWidth * 4.5f;
|
|
|
|
grassTrans.localPosition = new Vector3(newGrassX, grassPos.y, grassPos.z);
|
|
|
|
// Dots scroll
|
|
var dotsPos = dotsTrans.localPosition;
|
|
|
|
var newDotsX = dotsPos.x + (scrollRate * Time.deltaTime);
|
|
newDotsX %= dotsWidth;
|
|
|
|
dotsTrans.localPosition = new Vector3(newDotsX, dotsPos.y, dotsPos.z);
|
|
}
|
|
|
|
private void LateUpdate()
|
|
{
|
|
if (!isMarching) return;
|
|
isFlicking = false;
|
|
}
|
|
|
|
public void SetCollectThresholds(int thresholdEvolve, int limit, bool force, int forceAmount)
|
|
{
|
|
farmer.plantThreshold = thresholdEvolve;
|
|
farmer.plantLimit = limit;
|
|
if (force) Farmer.collectedPlants = forceAmount;
|
|
farmer.UpdatePlants();
|
|
}
|
|
|
|
private void SetInitTresholds(double beat)
|
|
{
|
|
var lastCollect = GameManager.instance.Beatmap.Entities.FindLast(c => c.datamodel == "cropStomp/plantCollect" && c.beat < beat);
|
|
if (lastCollect == null) return;
|
|
SetCollectThresholds(lastCollect["threshold"], lastCollect["limit"], lastCollect["force"], lastCollect["forceAmount"]);
|
|
}
|
|
|
|
public void CollectPlant(int veggieType)
|
|
{
|
|
farmer.CollectPlant(veggieType);
|
|
}
|
|
|
|
private void PlayAnims()
|
|
{
|
|
// Step.
|
|
if (currentMarchBeat % 2 != 0)
|
|
{
|
|
// Don't step if already stomped.
|
|
if (!isStepping)
|
|
{
|
|
stepCount += 1;
|
|
|
|
var stepAnim = (stepCount % 2 != 0) ? "StepFront" : "StepBack";
|
|
legsAnim.DoScaledAnimationAsync(stepAnim, 0.5f);
|
|
|
|
isStepping = true;
|
|
}
|
|
}
|
|
// Lift.
|
|
else
|
|
{
|
|
var liftAnim = (stepCount % 2 != 0) ? "LiftBack" : "LiftFront";
|
|
legsAnim.DoScaledAnimationAsync(liftAnim, 0.5f);
|
|
|
|
var farmerPos = farmerTrans.localPosition;
|
|
farmerTrans.localPosition = new Vector3(farmerPos.x - stepDistance, farmerPos.y, farmerPos.z);
|
|
|
|
isStepping = false;
|
|
}
|
|
}
|
|
|
|
public void StartMarching(double beat)
|
|
{
|
|
marchStartBeat = beat;
|
|
marchOffset = marchStartBeat % 1;
|
|
currentMarchBeat = 0;
|
|
stepCount = 0;
|
|
|
|
farmer.nextStompBeat = beat;
|
|
}
|
|
|
|
public void Stomp()
|
|
{
|
|
// Don't increment step counter if autostep stepped already.
|
|
if (!isStepping) stepCount += 1;
|
|
|
|
var stompAnim = (stepCount % 2 != 0) ? "StompFront" : "StompBack";
|
|
|
|
legsAnim.DoScaledAnimationAsync(stompAnim, 0.5f);
|
|
|
|
SoundByte.PlayOneShotGame("cropStomp/stomp");
|
|
|
|
if (shakeTween != null) shakeTween.Kill(true);
|
|
|
|
DOTween.Punch(() =>
|
|
GameCamera.AdditionalPosition,
|
|
x => GameCamera.AdditionalPosition = x,
|
|
new Vector3(0, 0.75f, 0), Conductor.instance.pitchedSecPerBeat * 0.5f, 18, 1f
|
|
);
|
|
|
|
isStepping = true;
|
|
}
|
|
|
|
private void SpawnVeggie(double beat, double startBeat, bool isMole)
|
|
{
|
|
var newVeggie = Instantiate(isMole ? baseMole : baseVeggie, veggieHolder).GetComponent<Veggie>();
|
|
|
|
newVeggie.targetBeat = beat;
|
|
|
|
var veggieX = (beat - startBeat) * -stepDistance / 2f;
|
|
newVeggie.transform.localPosition = new Vector3((float)veggieX, 0f, 0f);
|
|
newVeggie.Init();
|
|
newVeggie.gameObject.SetActive(true);
|
|
}
|
|
|
|
public static void MarchInactive(double beat)
|
|
{
|
|
if (GameManager.instance.currentGame == "cropStomp") return;
|
|
inactiveStart = beat;
|
|
RiqEntity gameSwitch = GameManager.instance.Beatmap.Entities.Find(c => c.beat >= beat && c.datamodel == "gameManager/switchGame/cropStomp");
|
|
if (gameSwitch == null) return;
|
|
int length = (int)Math.Ceiling((gameSwitch.beat - beat) / 2);
|
|
MultiSound.Sound[] sounds = new MultiSound.Sound[length];
|
|
for(int i = 0; i < length; i++) {
|
|
sounds[i] = new MultiSound.Sound("cropStomp/hmm", beat + (i * 2));
|
|
}
|
|
MultiSound.Play(sounds, forcePlay: true);
|
|
}
|
|
}
|
|
}
|