d5ae99d8ba
* add accuracy display * temp BG for show * separate overlays prefab make proper shader for star effects * aim shakiness display * implement testing skill star * fully functional skill star * separate section display from editor * fully separate chart section display from timeline * add section to overlays * fix nullreference issues * start game layout settings * add game settings script * fix nonfunctioning scoring * invert y position logic on timing bar * add perfect challenge functionality * fix section not showing up in editor add perfect challenge option * add timing display minimal mode * Update PerfectAndPractice.png * show gismo for minigame bounds in editor * add ability to disable overlays in editor * prepare medals add new timing display graphic * hide screen preview * per-axis camera control added per request * section medals basic functionality * add medal get animations * fix bug with perfect icons * visual enhancements * adjust look of timing display minmode address audio ducking issues(?) * prepare overlay lyt editor add viewport pan, rotate, scale adjust audio setting * add layout editor UI elements * dynamic overlay creation * fix default single timing disp * set up overlay settings controls * start UI events * runtime uuid for component reference * layout editor affects overlay elements * show overlay element previews while editing * advanced audio settings * fix bug in drop-down creation * fallback defaults for the new stuff * fix textbox & overlay visibility bugs
264 lines
11 KiB
C#
264 lines
11 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
|
|
using DG.Tweening;
|
|
using HeavenStudio.Util;
|
|
using Starpelly;
|
|
|
|
using HeavenStudio.Common;
|
|
|
|
namespace HeavenStudio.Games
|
|
{
|
|
|
|
public class PlayerActionEvent : PlayerActionObject
|
|
{
|
|
public static bool EnableAutoplayCheat = false;
|
|
public delegate void ActionEventCallback(PlayerActionEvent caller);
|
|
public delegate void ActionEventCallbackState(PlayerActionEvent caller, float state);
|
|
|
|
public ActionEventCallbackState OnHit; //Function to trigger when an input has been done perfectly
|
|
public ActionEventCallback OnMiss; //Function to trigger when an input has been missed
|
|
public ActionEventCallback OnBlank; //Function to trigger when an input has been recorded while this is pending
|
|
|
|
public ActionEventCallback OnDestroy; //Function to trigger whenever this event gets destroyed. /!\ Shouldn't be used for a minigame! Use OnMiss instead /!\
|
|
|
|
public float startBeat;
|
|
public float timer;
|
|
|
|
public bool canHit = true; //Indicates if you can still hit the cue or not. If set to false, it'll guarantee a miss
|
|
public bool enabled = true; //Indicates if the PlayerActionEvent is enabled. If set to false, it'll not trigger any events and destroy itself AFTER it's not relevant anymore
|
|
|
|
public bool autoplayOnly = false; //Indicates if the input event only triggers when it's autoplay. If set to true, NO Miss or Blank events will be triggered when you're not autoplaying.
|
|
|
|
public bool noAutoplay = false; //Indicates if this PlayerActionEvent is recognized by the autoplay. /!\ Overrides autoPlayOnly /!\
|
|
|
|
public InputType inputType; //The type of input. Check the InputType class to see a list of all of them
|
|
|
|
public bool perfectOnly = false; //Indicates that the input only recognize perfect inputs.
|
|
|
|
public bool countsForAccuracy = true; //Indicates if the input counts for the accuracy or not. If set to false, it'll not be counted in the accuracy calculation
|
|
|
|
public void setHitCallback(ActionEventCallbackState OnHit)
|
|
{
|
|
this.OnHit = OnHit;
|
|
}
|
|
|
|
public void setMissCallback(ActionEventCallback OnMiss)
|
|
{
|
|
this.OnMiss = OnMiss;
|
|
}
|
|
|
|
public void Enable() { enabled = true; }
|
|
public void Disable() { enabled = false; }
|
|
|
|
public void CanHit(bool canHit)
|
|
{
|
|
this.canHit = canHit;
|
|
}
|
|
|
|
|
|
public void Update()
|
|
{
|
|
if(!Conductor.instance.NotStopped()){CleanUp();} // If the song is stopped entirely in the editor, destroy itself as we don't want duplicates
|
|
|
|
if (noAutoplay && autoplayOnly) autoplayOnly = false;
|
|
if (noAutoplay && triggersAutoplay){ triggersAutoplay = false; }
|
|
if (!enabled) return;
|
|
|
|
double normalizedTime = GetNormalizedTime();
|
|
double stateProg = ((normalizedTime - Minigame.PerfectTime()) / (Minigame.LateTime() - Minigame.PerfectTime()) - 0.5f) * 2;
|
|
StateCheck(normalizedTime);
|
|
|
|
//BUGFIX: ActionEvents destroyed too early
|
|
if (normalizedTime > Minigame.EndTime()) Miss();
|
|
|
|
|
|
if (IsCorrectInput() && !autoplayOnly)
|
|
{
|
|
if (state.perfect)
|
|
{
|
|
Hit(stateProg, normalizedTime);
|
|
}
|
|
else if (state.early && !perfectOnly)
|
|
{
|
|
Hit(-1f, normalizedTime);
|
|
}
|
|
else if (state.late && !perfectOnly)
|
|
{
|
|
Hit(1f, normalizedTime);
|
|
}
|
|
else
|
|
{
|
|
Blank();
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool IsExpectingInputNow()
|
|
{
|
|
double normalizedBeat = GetNormalizedTime();
|
|
return normalizedBeat > Minigame.EarlyTime() && normalizedBeat < Minigame.EndTime();
|
|
}
|
|
|
|
double GetNormalizedTime()
|
|
{
|
|
var cond = Conductor.instance;
|
|
double currTime = cond.GetSongPosFromBeat(cond.songPositionInBeatsAsDouble);
|
|
double targetTime = cond.GetSongPosFromBeat(startBeat + timer);
|
|
double min = targetTime - 1f;
|
|
double max = targetTime + 1f;
|
|
return 1f + (((currTime - min) / (max - min))-0.5f)*2;
|
|
}
|
|
|
|
public bool IsCorrectInput()
|
|
{
|
|
// This one is a mouthful but it's an evil good to detect the correct input
|
|
// Forgive me for those input type names
|
|
return (
|
|
//General inputs, both down and up
|
|
(PlayerInput.Pressed() && inputType.HasFlag(InputType.STANDARD_DOWN)) ||
|
|
(PlayerInput.AltPressed() && inputType.HasFlag(InputType.STANDARD_ALT_DOWN)) ||
|
|
(PlayerInput.GetAnyDirectionDown() && inputType.HasFlag(InputType.DIRECTION_DOWN)) ||
|
|
(PlayerInput.PressedUp() && inputType.HasFlag(InputType.STANDARD_UP)) ||
|
|
(PlayerInput.AltPressedUp() && inputType.HasFlag(InputType.STANDARD_ALT_UP)) ||
|
|
(PlayerInput.GetAnyDirectionUp() && inputType.HasFlag(InputType.DIRECTION_UP)) ||
|
|
//Specific directional inputs
|
|
(PlayerInput.GetSpecificDirectionDown(PlayerInput.DOWN) && inputType.HasFlag(InputType.DIRECTION_DOWN_DOWN)) ||
|
|
(PlayerInput.GetSpecificDirectionDown(PlayerInput.UP) && inputType.HasFlag(InputType.DIRECTION_UP_DOWN)) ||
|
|
(PlayerInput.GetSpecificDirectionDown(PlayerInput.LEFT) && inputType.HasFlag(InputType.DIRECTION_LEFT_DOWN)) ||
|
|
(PlayerInput.GetSpecificDirectionDown(PlayerInput.RIGHT) && inputType.HasFlag(InputType.DIRECTION_RIGHT_DOWN)) ||
|
|
|
|
(PlayerInput.GetSpecificDirectionUp(PlayerInput.DOWN) && inputType.HasFlag(InputType.DIRECTION_DOWN_UP)) ||
|
|
(PlayerInput.GetSpecificDirectionUp(PlayerInput.UP) && inputType.HasFlag(InputType.DIRECTION_UP_UP)) ||
|
|
(PlayerInput.GetSpecificDirectionUp(PlayerInput.LEFT) && inputType.HasFlag(InputType.DIRECTION_LEFT_UP)) ||
|
|
(PlayerInput.GetSpecificDirectionUp(PlayerInput.RIGHT) && inputType.HasFlag(InputType.DIRECTION_RIGHT_UP))
|
|
);
|
|
}
|
|
|
|
|
|
//For the Autoplay
|
|
public override void OnAce()
|
|
{
|
|
if (EnableAutoplayCheat)
|
|
{
|
|
Hit(0f, 1f);
|
|
}
|
|
else
|
|
{
|
|
double normalizedBeat = GetNormalizedTime();
|
|
double stateProg = ((normalizedBeat - Minigame.PerfectTime()) / (Minigame.LateTime() - Minigame.PerfectTime()) - 0.5f) * 2;
|
|
Hit(stateProg, normalizedBeat);
|
|
}
|
|
}
|
|
|
|
//The state parameter is either -1 -> Early, 0 -> Perfect, 1 -> Late
|
|
public void Hit(double state, double time)
|
|
{
|
|
if (OnHit != null && enabled)
|
|
{
|
|
if(canHit)
|
|
{
|
|
double normalized = time - 1f;
|
|
int offset = Mathf.CeilToInt((float)normalized * 1000);
|
|
GameManager.instance.AvgInputOffset = offset;
|
|
OnHit(this, (float) state);
|
|
|
|
CleanUp();
|
|
if (countsForAccuracy && !(noAutoplay || autoplayOnly) && isEligible)
|
|
{
|
|
GameManager.instance.ScoreInputAccuracy(TimeToAccuracy(time), time > 1.0, time);
|
|
if (state >= 1f || state <= -1f)
|
|
{
|
|
GoForAPerfect.instance.Miss();
|
|
SectionMedalsManager.instance.MakeIneligible();
|
|
}
|
|
else
|
|
{
|
|
GoForAPerfect.instance.Hit();
|
|
}
|
|
}
|
|
} else
|
|
{
|
|
Blank();
|
|
}
|
|
}
|
|
}
|
|
|
|
double TimeToAccuracy(double time)
|
|
{
|
|
if (time >= Minigame.AceStartTime() && time <= Minigame.AceEndTime())
|
|
{
|
|
// Ace
|
|
return 1.0;
|
|
}
|
|
|
|
double state = 0;
|
|
if (time >= Minigame.PerfectTime() && time <= Minigame.LateTime())
|
|
{
|
|
// Good Hit
|
|
if (time > 1.0)
|
|
{
|
|
// late half of timing window
|
|
state = 1.0 - ((time - Minigame.AceEndTime()) / (Minigame.LateTime() - Minigame.AceEndTime()));
|
|
state *= 1.0 - Minigame.rankHiThreshold;
|
|
state += Minigame.rankHiThreshold;
|
|
}
|
|
else
|
|
{
|
|
//early half of timing window
|
|
state = ((time - Minigame.PerfectTime()) / (Minigame.AceStartTime() - Minigame.PerfectTime()));
|
|
state *= 1.0 - Minigame.rankHiThreshold;
|
|
state += Minigame.rankHiThreshold;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (time > 1.0)
|
|
{
|
|
// late half of timing window
|
|
state = 1.0 - ((time - Minigame.LateTime()) / (Minigame.EndTime() - Minigame.LateTime()));
|
|
state *= Minigame.rankOkThreshold;
|
|
}
|
|
else
|
|
{
|
|
//early half of timing window
|
|
state = ((time - Minigame.PerfectTime()) / (Minigame.AceStartTime() - Minigame.PerfectTime()));
|
|
state *= Minigame.rankOkThreshold;
|
|
}
|
|
}
|
|
return state;
|
|
}
|
|
|
|
public void Miss()
|
|
{
|
|
if (OnMiss != null && enabled && !autoplayOnly)
|
|
{
|
|
OnMiss(this);
|
|
}
|
|
|
|
CleanUp();
|
|
if (countsForAccuracy && !(noAutoplay || autoplayOnly))
|
|
{
|
|
GameManager.instance.ScoreInputAccuracy(0, true, 2.0, 1.0, false);
|
|
GoForAPerfect.instance.Miss();
|
|
SectionMedalsManager.instance.MakeIneligible();
|
|
}
|
|
}
|
|
|
|
public void Blank()
|
|
{
|
|
if(OnBlank != null && enabled && !autoplayOnly)
|
|
{
|
|
OnBlank(this);
|
|
}
|
|
}
|
|
|
|
public void CleanUp()
|
|
{
|
|
OnDestroy(this);
|
|
Destroy(this.gameObject);
|
|
}
|
|
|
|
}
|
|
} |