caf7d9465f
* add pause menu assets * layout and animation for pause * make play mode prefab function re-assign unused class inheritance * remove filepath * don't init medals twice * remove PlayerActionObject * initial attempt at anti-note lock TODO: circumvent inputs clearing themselves making the functionality not work * properly implement input lock prevention * fix error on editor open * functional pause menu * bugfix * make unpausing not reset current play statistics * serialize initializer components in inspector instead of procedurally generating * sanity check * note for fade * make flashes in the camera prefabs instead of in world space remove / reorganize script files address issue #411 * fix bug with perfect campaign make minigame transitions hide the game canvas adjust animation of the song credits textbox * fully functional intro scene (placeholder for future title screen) refactored entire game loading procedure re-organized some files * add interaction query to disclaimer text * reword legal * anchor section medals to section display more tempo change placement controls * operation order bugfix * prep for future ratings and stats * loading text * autoload opening scene * splash screen adjustments added setting to force enable splash screen * adjust setting entry
416 lines
14 KiB
C#
416 lines
14 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
|
|
using HeavenStudio.Util;
|
|
|
|
namespace HeavenStudio.Games.Scripts_SpaceSoccer
|
|
{
|
|
public class Kicker : MonoBehaviour
|
|
{
|
|
SpaceSoccer game;
|
|
|
|
[Header("Properties")]
|
|
public bool canKick = true; //why was this false by default???
|
|
public bool canHighKick;
|
|
private bool kickPrepare = false;
|
|
public bool kickLeft;
|
|
bool kickLeftWhiff;
|
|
public float dispenserBeat; //unused
|
|
public int kickTimes = 0;
|
|
public bool player;
|
|
private string animName = "Enter";
|
|
private float animLength;
|
|
private float animStartBeat;
|
|
private EasingFunction.Ease ease;
|
|
bool stopBall;
|
|
|
|
[Header("Components")]
|
|
private Animator anim;
|
|
public Ball ball;
|
|
[SerializeField] private Animator enterExitAnim;
|
|
|
|
PlayerActionEvent nextHit;
|
|
PlayerActionEvent nextAutoKick;
|
|
|
|
private void Awake()
|
|
{
|
|
game = SpaceSoccer.instance;
|
|
anim = GetComponent<Animator>();
|
|
}
|
|
|
|
public void SetAnimParams(float beat, float length, string anim, int easeToPut)
|
|
{
|
|
animStartBeat = beat;
|
|
animLength = length;
|
|
animName = anim;
|
|
ease = (EasingFunction.Ease)easeToPut;
|
|
EasingFunction.Function func = EasingFunction.GetEasingFunction(ease);
|
|
float newAnimPos = func(0, 1, 0);
|
|
enterExitAnim.DoNormalizedAnimation(animName, newAnimPos);
|
|
}
|
|
|
|
public void DispenseBall(float beat)
|
|
{
|
|
if (player)
|
|
{
|
|
nextHit = game.ScheduleInput(beat, ball.GetAnimLength(Ball.State.Dispensing), InputType.STANDARD_DOWN, KickJust, Miss, Out);
|
|
}
|
|
else
|
|
{
|
|
float beatToKick = beat + ball.GetAnimLength(Ball.State.Dispensing);
|
|
if (beatToKick < Conductor.instance.songPositionInBeats) beatToKick = ball.nextAnimBeat;
|
|
if (ball.state == Ball.State.HighKicked)
|
|
{
|
|
BeatAction.New(this.gameObject, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beatToKick - 0.5f, delegate { Kick(true, true); }),
|
|
new BeatAction.Action(beatToKick, delegate { Toe(true); }),
|
|
new BeatAction.Action(beatToKick + ball.GetAnimLength(Ball.State.Toe), delegate { KickCheck(true, false, beatToKick + ball.GetAnimLength(Ball.State.Toe)); }),
|
|
});
|
|
}
|
|
else
|
|
{
|
|
BeatAction.New(this.gameObject, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beatToKick, delegate { KickCheck(true, false, beatToKick); }),
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
public void Kick(bool hit, bool highKick = false)
|
|
{
|
|
if (stopBall) return;
|
|
|
|
if (player)
|
|
{
|
|
Jukebox.PlayOneShotGame("spaceSoccer/kick");
|
|
}
|
|
|
|
if (hit)
|
|
{
|
|
if (highKick)
|
|
{
|
|
if (kickLeft)
|
|
{
|
|
anim.DoScaledAnimationAsync("HighKickLeft_0", 0.5f);
|
|
}
|
|
else
|
|
{
|
|
anim.DoScaledAnimationAsync("HighKickRight_0", 0.5f);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (kickLeft)
|
|
{
|
|
anim.DoScaledAnimationAsync("KickLeft", 0.5f);
|
|
}
|
|
else
|
|
{
|
|
anim.DoScaledAnimationAsync("KickRight", 0.5f);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (highKick)
|
|
{
|
|
if (kickLeftWhiff)
|
|
{
|
|
anim.DoScaledAnimationAsync("HighKickLeft_0", 0.5f);
|
|
}
|
|
else
|
|
{
|
|
anim.DoScaledAnimationAsync("HighKickRight_0", 0.5f);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (kickLeftWhiff)
|
|
{
|
|
anim.DoScaledAnimationAsync("KickLeft", 0.5f);
|
|
}
|
|
else
|
|
{
|
|
anim.DoScaledAnimationAsync("KickRight", 0.5f);
|
|
}
|
|
}
|
|
kickLeftWhiff = !kickLeftWhiff;
|
|
}
|
|
|
|
|
|
if (ball == null) return;
|
|
|
|
if (highKick == false)
|
|
{
|
|
kickTimes++;
|
|
if (ball != null && hit)
|
|
ball.Kick(player);
|
|
}
|
|
else
|
|
{
|
|
kickPrepare = true;
|
|
}
|
|
}
|
|
|
|
public void HighKick(bool hit)
|
|
{
|
|
if (stopBall) return;
|
|
kickTimes++;
|
|
if (hit)
|
|
{
|
|
if (kickLeft)
|
|
{
|
|
anim.DoScaledAnimationAsync("HighKickLeft_0", 0.5f);
|
|
}
|
|
else
|
|
{
|
|
anim.DoScaledAnimationAsync("HighKickRight_0", 0.5f);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (kickLeftWhiff)
|
|
{
|
|
anim.DoScaledAnimationAsync("HighKickLeft_0", 0.5f);
|
|
}
|
|
else
|
|
{
|
|
anim.DoScaledAnimationAsync("HighKickRight_0", 0.5f);
|
|
}
|
|
kickLeftWhiff = !kickLeftWhiff;
|
|
}
|
|
|
|
if (player) Jukebox.PlayOneShotGame("spaceSoccer/highkicktoe1");
|
|
if (hit && ball)
|
|
{
|
|
ball.HighKick();
|
|
|
|
if (player) Jukebox.PlayOneShotGame("spaceSoccer/highkicktoe1_hit");
|
|
}
|
|
|
|
}
|
|
|
|
public void Toe(bool hit)
|
|
{
|
|
if (stopBall) return;
|
|
if (kickLeft)
|
|
{
|
|
anim.DoScaledAnimationAsync("ToeLeft", 0.5f);
|
|
}
|
|
else
|
|
{
|
|
anim.DoScaledAnimationAsync("ToeRight", 0.5f);
|
|
}
|
|
|
|
if (player)
|
|
{
|
|
Jukebox.PlayOneShotGame("spaceSoccer/highkicktoe3");
|
|
if (hit && ball)
|
|
{
|
|
Jukebox.PlayOneShotGame("spaceSoccer/highkicktoe3_hit");
|
|
}
|
|
}
|
|
|
|
if (hit && ball)
|
|
ball.Toe();
|
|
|
|
kickTimes++;
|
|
kickPrepare = false;
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
float normalizedBeat = Conductor.instance.GetPositionFromBeat(animStartBeat, animLength);
|
|
if (normalizedBeat >= 0 && normalizedBeat <= 1)
|
|
{
|
|
EasingFunction.Function func = EasingFunction.GetEasingFunction(ease);
|
|
float newAnimPos = func(0, 1, normalizedBeat);
|
|
enterExitAnim.DoNormalizedAnimation(animName, newAnimPos);
|
|
}
|
|
if (kickTimes % 2 == 0)
|
|
{
|
|
kickLeft = false;
|
|
}
|
|
else
|
|
{
|
|
kickLeft = true;
|
|
}
|
|
|
|
var highKicks = GameManager.instance.Beatmap.entities.FindAll(c => c.datamodel == "spaceSoccer/high kick-toe!");
|
|
for (int i = 0; i < highKicks.Count; i++)
|
|
{
|
|
if ((highKicks[i].beat - 0.15f) <= Conductor.instance.songPositionInBeats && highKicks[i].beat + 1f > Conductor.instance.songPositionInBeats)
|
|
{
|
|
canHighKick = true;
|
|
canKick = false;
|
|
|
|
if (ball)
|
|
{
|
|
ball.highKickSwing = highKicks[i].swing;
|
|
if (ball.highKickSwing == 0f)
|
|
ball.highKickSwing = 0.5f;
|
|
}
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
canKick = true;
|
|
canHighKick = false;
|
|
}
|
|
}
|
|
|
|
if (player)
|
|
{
|
|
if (stopBall) return;
|
|
if (PlayerInput.Pressed() && !game.IsExpectingInputNow(InputType.STANDARD_DOWN))
|
|
{
|
|
if (ball == null)
|
|
KickCheck(false, true);
|
|
else
|
|
Kick(false, ball.canKick);
|
|
|
|
}
|
|
if (PlayerInput.PressedUp() && ball != null)
|
|
{
|
|
if (ball.waitKickRelease)
|
|
{
|
|
ball.waitKickRelease = false;
|
|
}
|
|
else if (ball.canKick && !game.IsExpectingInputNow(InputType.STANDARD_UP))
|
|
{
|
|
ball.canKick = false;
|
|
Kick(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private void KickCheck(bool hit, bool overrideState = false, float beat = 0f)
|
|
{
|
|
if (stopBall) return;
|
|
if (canHighKick)
|
|
{
|
|
HighKick(hit);
|
|
if (!player)
|
|
{
|
|
BeatAction.New(this.gameObject, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beat + ball.GetAnimLength(Ball.State.Kicked), delegate { Kick(true, true); }),
|
|
new BeatAction.Action(beat + ball.GetAnimLength(Ball.State.Toe), delegate { Toe(true); }),
|
|
new BeatAction.Action(beat + ball.GetAnimLength(Ball.State.Toe) + 1.5f, delegate { KickCheck(true, false, beat + ball.GetAnimLength(Ball.State.Toe) + 1.5f); }),
|
|
});
|
|
}
|
|
}
|
|
else if (canKick)
|
|
{
|
|
Kick(hit);
|
|
if (!player)
|
|
{
|
|
BeatAction.New(this.gameObject, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beat + ball.GetAnimLength(Ball.State.Kicked), delegate { KickCheck(true, false, beat + ball.GetAnimLength(Ball.State.Kicked)); }),
|
|
});
|
|
}
|
|
}
|
|
else if (!canKick && !canHighKick && overrideState)
|
|
{
|
|
Kick(hit);
|
|
if (!player)
|
|
{
|
|
BeatAction.New(this.gameObject, new List<BeatAction.Action>()
|
|
{
|
|
new BeatAction.Action(beat + ball.GetAnimLength(Ball.State.Kicked), delegate { KickCheck(true, false, beat + ball.GetAnimLength(Ball.State.Kicked)); }),
|
|
});
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
public void StopBall(bool stop)
|
|
{
|
|
stopBall = stop;
|
|
if (ball != null && stop) Destroy(ball.gameObject);
|
|
}
|
|
|
|
void MissBall(float targetBeat)
|
|
{
|
|
if (stopBall) return;
|
|
|
|
var cond = Conductor.instance;
|
|
ball = null;
|
|
// queue the miss sound
|
|
MultiSound.Play(new MultiSound.Sound[] { new MultiSound.Sound("spaceSoccer/missNeutral", targetBeat + (float)cond.SecsToBeats(Minigame.EndTime()-1,
|
|
cond.GetBpmAtBeat(targetBeat)), Jukebox.GetPitchFromCents(UnityEngine.Random.Range(-75, 75), false)) });
|
|
}
|
|
|
|
private void KickJust(PlayerActionEvent caller, float state)
|
|
{
|
|
if (stopBall) return;
|
|
if (ball == null || state >= 1f || state <= -1f) { //todo: proper near miss feedback
|
|
KickCheck(false, true);
|
|
MissBall(caller.startBeat + caller.timer);
|
|
return;
|
|
}
|
|
KickCheck(true);
|
|
if (canHighKick)
|
|
{
|
|
// queue high kick inputs
|
|
nextHit = game.ScheduleInput(caller.startBeat + caller.timer, ball.GetAnimLength(Ball.State.Toe), InputType.STANDARD_UP, ToeJust, Miss, Out);
|
|
nextAutoKick = game.ScheduleAutoplayInput(caller.startBeat + caller.timer, ball.GetAnimLength(Ball.State.Kicked), InputType.STANDARD_DOWN, ToePrepareJust, Out, Out);
|
|
ball.canKick = true;
|
|
ball.waitKickRelease = true;
|
|
}
|
|
else
|
|
{
|
|
// queue normal kick input
|
|
nextHit = game.ScheduleInput(caller.startBeat + caller.timer, ball.GetAnimLength(Ball.State.Kicked), InputType.STANDARD_DOWN, KickJust, Miss, Out);
|
|
}
|
|
}
|
|
|
|
private void Miss(PlayerActionEvent caller)
|
|
{
|
|
if (stopBall) return;
|
|
if (ball != null)
|
|
MissBall(caller.startBeat + caller.timer);
|
|
|
|
// if this were any other keep the beat game you'd cue the next input here
|
|
}
|
|
|
|
private void ToeJust(PlayerActionEvent caller, float state)
|
|
{
|
|
if (stopBall) return;
|
|
|
|
if (ball == null || (!ball.canKick) || state >= 1f || state <= -1f) { //todo: proper near miss feedback
|
|
Toe(false);
|
|
MissBall(caller.startBeat + caller.timer);
|
|
return;
|
|
}
|
|
Toe(true);
|
|
nextHit = game.ScheduleInput(caller.startBeat, 3f, InputType.STANDARD_DOWN, KickJust, Miss, Out);
|
|
ball.canKick = false;
|
|
}
|
|
|
|
private void ToePrepareJust(PlayerActionEvent caller, float state)
|
|
{
|
|
if (stopBall) return;
|
|
|
|
//autoplay only
|
|
Kick(true, true);
|
|
}
|
|
|
|
private void Out(PlayerActionEvent caller) {}
|
|
|
|
void OnDestroy()
|
|
{
|
|
if (nextHit != null)
|
|
nextHit.Disable();
|
|
if (nextAutoKick != null)
|
|
nextAutoKick.Disable();
|
|
if (ball != null) Destroy(ball.gameObject);
|
|
}
|
|
}
|
|
} |