mirror of
https://github.com/ninjamuffin99/Funkin.git
synced 2024-11-15 19:33:36 +00:00
369 lines
10 KiB
Haxe
369 lines
10 KiB
Haxe
package funkin.play;
|
|
|
|
import flixel.tweens.FlxEase;
|
|
import flixel.tweens.FlxTween;
|
|
import flixel.FlxSprite;
|
|
import funkin.graphics.FunkinSprite;
|
|
import funkin.modding.events.ScriptEventDispatcher;
|
|
import funkin.modding.module.ModuleHandler;
|
|
import funkin.modding.events.ScriptEvent;
|
|
import funkin.modding.events.ScriptEvent.CountdownScriptEvent;
|
|
import flixel.util.FlxTimer;
|
|
import funkin.util.EaseUtil;
|
|
import funkin.audio.FunkinSound;
|
|
import openfl.utils.Assets;
|
|
import funkin.data.notestyle.NoteStyleRegistry;
|
|
import funkin.play.notes.notestyle.NoteStyle;
|
|
|
|
class Countdown
|
|
{
|
|
/**
|
|
* The current step of the countdown.
|
|
*/
|
|
public static var countdownStep(default, null):CountdownStep = BEFORE;
|
|
|
|
/**
|
|
* Which alternate graphic/sound on countdown to use.
|
|
* This is set via the current notestyle.
|
|
* For example, in Week 6 it is `pixel`.
|
|
*/
|
|
public static var soundSuffix:String = '';
|
|
|
|
/**
|
|
* Which alternate graphic on countdown to use.
|
|
* You can set this via script.
|
|
* For example, in Week 6 it is `-pixel`.
|
|
*/
|
|
public static var graphicSuffix:String = '';
|
|
|
|
static var noteStyle:NoteStyle;
|
|
|
|
static var fallbackNoteStyle:Null<NoteStyle>;
|
|
|
|
static var isPixel:Bool = false;
|
|
|
|
/**
|
|
* The currently running countdown. This will be null if there is no countdown running.
|
|
*/
|
|
static var countdownTimer:FlxTimer = null;
|
|
|
|
/**
|
|
* Performs the countdown.
|
|
* Pauses the song, plays the countdown graphics/sound, and then starts the song.
|
|
* This will automatically stop and restart the countdown if it is already running.
|
|
* @returns `false` if the countdown was cancelled by a script.
|
|
*/
|
|
public static function performCountdown():Bool
|
|
{
|
|
countdownStep = BEFORE;
|
|
var cancelled:Bool = propagateCountdownEvent(countdownStep);
|
|
if (cancelled)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Stop any existing countdown.
|
|
stopCountdown();
|
|
|
|
PlayState.instance.isInCountdown = true;
|
|
Conductor.instance.update(PlayState.instance.startTimestamp + Conductor.instance.beatLengthMs * -5);
|
|
// Handle onBeatHit events manually
|
|
// @:privateAccess
|
|
// PlayState.instance.dispatchEvent(new SongTimeScriptEvent(SONG_BEAT_HIT, 0, 0));
|
|
|
|
// The timer function gets called based on the beat of the song.
|
|
countdownTimer = new FlxTimer();
|
|
|
|
countdownTimer.start(Conductor.instance.beatLengthMs / 1000, function(tmr:FlxTimer) {
|
|
if (PlayState.instance == null)
|
|
{
|
|
tmr.cancel();
|
|
return;
|
|
}
|
|
|
|
countdownStep = decrement(countdownStep);
|
|
|
|
// onBeatHit events are now properly dispatched by the Conductor even at negative timestamps,
|
|
// so calling this is no longer necessary.
|
|
// PlayState.instance.dispatchEvent(new SongTimeScriptEvent(SONG_BEAT_HIT, 0, 0));
|
|
|
|
// Countdown graphic.
|
|
showCountdownGraphic(countdownStep);
|
|
|
|
// Countdown sound.
|
|
playCountdownSound(countdownStep);
|
|
|
|
// Event handling bullshit.
|
|
var cancelled:Bool = propagateCountdownEvent(countdownStep);
|
|
|
|
if (cancelled)
|
|
{
|
|
pauseCountdown();
|
|
}
|
|
|
|
if (countdownStep == AFTER)
|
|
{
|
|
stopCountdown();
|
|
}
|
|
}, 5); // Before, 3, 2, 1, GO!, After
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* @return TRUE if the event was cancelled.
|
|
*/
|
|
static function propagateCountdownEvent(index:CountdownStep):Bool
|
|
{
|
|
var event:ScriptEvent;
|
|
|
|
switch (index)
|
|
{
|
|
case BEFORE:
|
|
event = new CountdownScriptEvent(COUNTDOWN_START, index);
|
|
case THREE | TWO | ONE | GO: // I didn't know you could use `|` in a switch/case block!
|
|
event = new CountdownScriptEvent(COUNTDOWN_STEP, index);
|
|
case AFTER:
|
|
event = new CountdownScriptEvent(COUNTDOWN_END, index, false);
|
|
default:
|
|
return true;
|
|
}
|
|
|
|
// Modules, stages, characters.
|
|
@:privateAccess
|
|
PlayState.instance.dispatchEvent(event);
|
|
|
|
return event.eventCanceled;
|
|
}
|
|
|
|
/**
|
|
* Pauses the countdown at the current step. You can start it up again later by calling resumeCountdown().
|
|
*
|
|
* If you want to call this from a module, it's better to use the event system and cancel the onCountdownStep event.
|
|
*/
|
|
public static function pauseCountdown():Void
|
|
{
|
|
if (countdownTimer != null && !countdownTimer.finished)
|
|
{
|
|
countdownTimer.active = false;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Resumes the countdown at the current step. Only makes sense if you called pauseCountdown() first.
|
|
*
|
|
* If you want to call this from a module, it's better to use the event system and cancel the onCountdownStep event.
|
|
*/
|
|
public static function resumeCountdown():Void
|
|
{
|
|
if (countdownTimer != null && !countdownTimer.finished)
|
|
{
|
|
countdownTimer.active = true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Stops the countdown at the current step. You will have to restart it again later.
|
|
*
|
|
* If you want to call this from a module, it's better to use the event system and cancel the onCountdownStart event.
|
|
*/
|
|
public static function stopCountdown():Void
|
|
{
|
|
if (countdownTimer != null)
|
|
{
|
|
countdownTimer.cancel();
|
|
countdownTimer.destroy();
|
|
countdownTimer = null;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Stops the current countdown, then starts the song for you.
|
|
*/
|
|
public static function skipCountdown():Void
|
|
{
|
|
stopCountdown();
|
|
// This will trigger PlayState.startSong()
|
|
Conductor.instance.update(0);
|
|
// PlayState.isInCountdown = false;
|
|
}
|
|
|
|
/**
|
|
* Resets the countdown. Only works if it's already running.
|
|
*/
|
|
public static function resetCountdown()
|
|
{
|
|
if (countdownTimer != null)
|
|
{
|
|
countdownTimer.reset();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Reset the countdown configuration to the default.
|
|
*/
|
|
public static function reset()
|
|
{
|
|
noteStyle = NoteStyleRegistry.instance.fetchDefault();
|
|
isPixel = false;
|
|
}
|
|
|
|
static function fetchNoteStyle():Void
|
|
{
|
|
var fetchedNoteStyle:NoteStyle = NoteStyleRegistry.instance.fetchEntry(PlayState.instance.currentChart.noteStyle);
|
|
if (fetchedNoteStyle == null) noteStyle = NoteStyleRegistry.instance.fetchDefault();
|
|
else
|
|
noteStyle = fetchedNoteStyle;
|
|
fallbackNoteStyle = NoteStyleRegistry.instance.fetchEntry(noteStyle.getFallbackID());
|
|
isPixel = false;
|
|
}
|
|
|
|
/**
|
|
* Retrieves the graphic to use for this step of the countdown.
|
|
*/
|
|
public static function showCountdownGraphic(index:CountdownStep):Void
|
|
{
|
|
var indexString:String = null;
|
|
switch (index)
|
|
{
|
|
case TWO:
|
|
indexString = 'ready';
|
|
case ONE:
|
|
indexString = 'set';
|
|
case GO:
|
|
indexString = 'go';
|
|
default:
|
|
// null
|
|
}
|
|
if (indexString == null) return;
|
|
|
|
var spritePath:String = null;
|
|
spritePath = resolveGraphicPath(indexString);
|
|
|
|
if (spritePath == null) return;
|
|
|
|
var countdownSprite:FunkinSprite = FunkinSprite.create(spritePath);
|
|
countdownSprite.scrollFactor.set(0, 0);
|
|
|
|
if (isGraphicPixel) countdownSprite.setGraphicSize(Std.int(countdownSprite.width * Constants.PIXEL_ART_SCALE));
|
|
else
|
|
countdownSprite.setGraphicSize(Std.int(countdownSprite.width * 0.7));
|
|
|
|
var fadeEase = FlxEase.cubeInOut;
|
|
if (isGraphicPixel) fadeEase = EaseUtil.stepped(8);
|
|
|
|
countdownSprite.antialiasing = !isPixel;
|
|
|
|
countdownSprite.cameras = [PlayState.instance.camHUD];
|
|
|
|
countdownSprite.updateHitbox();
|
|
|
|
// Fade sprite in, then out, then destroy it.
|
|
FlxTween.tween(countdownSprite, {alpha: 0}, Conductor.instance.beatLengthMs / 1000,
|
|
{
|
|
ease: fadeEase,
|
|
onComplete: function(twn:FlxTween) {
|
|
countdownSprite.destroy();
|
|
}
|
|
});
|
|
|
|
PlayState.instance.add(countdownSprite);
|
|
countdownSprite.screenCenter();
|
|
}
|
|
|
|
static function resolveGraphicPath(index:String):Null<String>
|
|
{
|
|
fetchNoteStyle();
|
|
var basePath:String = 'ui/countdown/';
|
|
var spritePath:String = basePath + noteStyle.id + '/$index';
|
|
|
|
while (!Assets.exists(Paths.image(spritePath)) && fallbackNoteStyle != null)
|
|
{
|
|
noteStyle = fallbackNoteStyle;
|
|
fallbackNoteStyle = NoteStyleRegistry.instance.fetchEntry(noteStyle.getFallbackID());
|
|
spritePath = basePath + noteStyle.id + '/$index';
|
|
}
|
|
if (noteStyle.isHoldNotePixel()) isPixel = true;
|
|
|
|
// If ABSOLUTELY nothing is found, revert it to default notestyle skin
|
|
if (!Assets.exists(Paths.image(spritePath)))
|
|
{
|
|
if (!isPixel) spritePath = basePath + Constants.DEFAULT_NOTE_STYLE + '/$index';
|
|
else
|
|
spritePath = basePath + Constants.DEFAULT_PIXEL_NOTE_STYLE + '/$index';
|
|
}
|
|
|
|
trace('Resolved sprite path: ' + Paths.image(spritePath));
|
|
return spritePath;
|
|
}
|
|
|
|
/**
|
|
* Retrieves the sound file to use for this step of the countdown.
|
|
*/
|
|
public static function playCountdownSound(step:CountdownStep):Void
|
|
{
|
|
return FunkinSound.playOnce(Paths.sound(resolveSoundPath(step)), Constants.COUNTDOWN_VOLUME);
|
|
}
|
|
|
|
static function resolveSoundPath(step:CountdownStep):Null<String>
|
|
{
|
|
if (step == CountdownStep.BEFORE || step == CountdownStep.AFTER) return null;
|
|
fetchNoteStyle();
|
|
var basePath:String = 'gameplay/countdown/';
|
|
var soundPath:String = basePath + noteStyle.id + '/intro$step';
|
|
|
|
while (!Assets.exists(Paths.sound(soundPath)) && fallbackNoteStyle != null)
|
|
{
|
|
noteStyle = fallbackNoteStyle;
|
|
fallbackNoteStyle = NoteStyleRegistry.instance.fetchEntry(noteStyle.getFallbackID());
|
|
soundPath = basePath + noteStyle.id + '/intro$step';
|
|
}
|
|
if (noteStyle.isHoldNotePixel()) isPixel = true;
|
|
|
|
// If ABSOLUTELY nothing is found, revert it to default notestyle sound
|
|
if (!Assets.exists(Paths.sound(soundPath)))
|
|
{
|
|
if (!isPixel) soundPath = basePath + Constants.DEFAULT_NOTE_STYLE + '/intro$step';
|
|
else
|
|
soundPath = basePath + Constants.DEFAULT_PIXEL_NOTE_STYLE + '/intro$step';
|
|
}
|
|
|
|
trace('Resolved sound path: ' + soundPath);
|
|
return soundPath;
|
|
}
|
|
|
|
public static function decrement(step:CountdownStep):CountdownStep
|
|
{
|
|
switch (step)
|
|
{
|
|
case BEFORE:
|
|
return THREE;
|
|
case THREE:
|
|
return TWO;
|
|
case TWO:
|
|
return ONE;
|
|
case ONE:
|
|
return GO;
|
|
case GO:
|
|
return AFTER;
|
|
|
|
default:
|
|
return AFTER;
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* The countdown step.
|
|
* This can't be an enum abstract because scripts may need it.
|
|
*/
|
|
enum CountdownStep
|
|
{
|
|
BEFORE;
|
|
THREE;
|
|
TWO;
|
|
ONE;
|
|
GO;
|
|
AFTER;
|
|
}
|