rufiusandGitHub
e458e868a4
The alt. animation toggle event currently does not support setting the suffix directly, but that's outside of the scope of adding this feature at the moment.
482 lines
16 KiB
Haxe
482 lines
16 KiB
Haxe
package funkin.game;
|
|
|
|
import flixel.math.FlxPoint;
|
|
import flixel.sound.FlxSound;
|
|
import flixel.tweens.FlxTween;
|
|
import flixel.util.FlxSignal.FlxTypedSignal;
|
|
import funkin.backend.chart.ChartData;
|
|
import funkin.backend.scripting.events.note.*;
|
|
import funkin.backend.system.Conductor;
|
|
import funkin.backend.system.Controls;
|
|
|
|
/**
|
|
* Group of strums, that contains the strums and notes.
|
|
* Used in PlayState.
|
|
**/
|
|
class StrumLine extends FlxTypedGroup<Strum> {
|
|
/**
|
|
* Signal that triggers whenever a note is hit. Similar to onPlayerHit and onDadHit, except strumline specific.
|
|
* To add a listener, do
|
|
* `strumLine.onHit.add(function(e:NoteHitEvent) {});`
|
|
*/
|
|
public var onHit:FlxTypedSignal<NoteHitEvent->Void> = new FlxTypedSignal<NoteHitEvent->Void>();
|
|
/**
|
|
* Signal that triggers whenever a note is missed. Similar to onPlayerMiss, except strumline specific.
|
|
* To add a listener, do
|
|
* `strumLine.onMiss.add(function(e:NoteMissEvent) {});`
|
|
*/
|
|
public var onMiss:FlxTypedSignal<NoteMissEvent->Void> = new FlxTypedSignal<NoteMissEvent->Void>();
|
|
/**
|
|
* Signal that triggers whenever a note is being updated. Similar to onNoteUpdate, except strumline specific.
|
|
* To add a listener, do
|
|
* `strumLine.onNoteUpdate.add(function(e:NoteUpdateEvent) {});`
|
|
*/
|
|
public var onNoteUpdate:FlxTypedSignal<NoteUpdateEvent->Void> = new FlxTypedSignal<NoteUpdateEvent->Void>();
|
|
/**
|
|
* Signal that triggers whenever a note is being deleted. Similar to onNoteDelete, except strumline specific.
|
|
* To add a listener, do
|
|
* `strumLine.onNoteDelete.add(function(e:SimpleNoteEvent) {});`
|
|
*/
|
|
public var onNoteDelete:FlxTypedSignal<SimpleNoteEvent->Void> = new FlxTypedSignal<SimpleNoteEvent->Void>();
|
|
/**
|
|
* Array containing all of the characters "attached" to those strums.
|
|
*/
|
|
public var characters:Array<Character>;
|
|
/**
|
|
* Whenever this strumline is controlled by cpu or not.
|
|
*/
|
|
public var cpu(default, set):Bool = false;
|
|
/**
|
|
* Whenever this strumline is from the opponent side or the player side.
|
|
*/
|
|
public var opponentSide:Bool = false;
|
|
/**
|
|
* Controls assigned to this strumline.
|
|
*/
|
|
public var controls:Controls = null;
|
|
/**
|
|
* Chart JSON data assigned to this StrumLine (Codename format)
|
|
*/
|
|
public var data:ChartStrumLine = null;
|
|
/**
|
|
* Whenever Ghost Tapping is enabled.
|
|
*/
|
|
@:isVar public var ghostTapping(get, set):Null<Bool> = null;
|
|
/**
|
|
* Group of all of the notes in this strumline. Using `forEach` on this group will only loop through the first notes for performance reasons.
|
|
*/
|
|
public var notes:NoteGroup;
|
|
/**
|
|
* Whenever alt animation is enabled on this strumline.
|
|
*/
|
|
public var altAnim(get, set):Bool;
|
|
/**
|
|
* Which animation suffix on characters that should be used when hitting notes.
|
|
*/
|
|
public var animSuffix(default, set):String = "";
|
|
/**
|
|
* The current animation suffix the strumline should use. Note that setting this will only take effect upon the alt. animation being reset.
|
|
*/
|
|
public var defaultAnimSuffix:String = Flags.DEFAULT_ALT_ANIM_SUFFIX;
|
|
/**
|
|
* TODO: Write documentation about this being a variable that can help when making multi key
|
|
*/
|
|
public var strumAnimPrefix = ["left", "down", "up", "right"];
|
|
/**
|
|
* Vocals sound (Vocals.ogg). Used for individual vocals per strumline.
|
|
*/
|
|
public var vocals:FlxSound;
|
|
/**
|
|
* Extra data that can be added to the strum line.
|
|
**/
|
|
public var extra:Map<String, Dynamic> = [];
|
|
|
|
private function get_ghostTapping() {
|
|
if (this.ghostTapping != null) return this.ghostTapping;
|
|
if (PlayState.instance != null) return PlayState.instance.ghostTapping;
|
|
return false;
|
|
}
|
|
|
|
private inline function set_ghostTapping(b:Bool):Bool
|
|
return this.ghostTapping = b;
|
|
|
|
|
|
private var startingPos:FlxPoint = FlxPoint.get(0,0);
|
|
/**
|
|
* The scale of the strums.
|
|
* If called after generate, the strums wont be scaled.
|
|
* You can only change it in the Charter.
|
|
**/
|
|
public var strumScale:Float = 1;
|
|
|
|
public function new(characters:Array<Character>, startingPos:FlxPoint, strumScale:Float, cpu:Bool = false, opponentSide:Bool = true, ?controls:Controls, ?vocalPrefix:String = "") {
|
|
super();
|
|
this.characters = characters;
|
|
this.startingPos = startingPos;
|
|
this.strumScale = strumScale;
|
|
this.cpu = cpu;
|
|
this.opponentSide = opponentSide;
|
|
this.controls = controls;
|
|
this.notes = new NoteGroup();
|
|
|
|
var v = Paths.voices(PlayState.SONG.meta.name, PlayState.difficulty, vocalPrefix);
|
|
vocals = vocalPrefix != "" ? FlxG.sound.load(Options.streamedVocals ? Assets.getMusic(v) : v) : new FlxSound();
|
|
vocals.persist = false;
|
|
}
|
|
|
|
/**
|
|
* Generates the notes for the strumline.
|
|
**/
|
|
public function generate(strumLine:ChartStrumLine, ?startTime:Float) {
|
|
// TODO: implement double generate call support if needed
|
|
|
|
var total = 0;
|
|
if (strumLine.notes != null) for(note in strumLine.notes) {
|
|
if (startTime != null && startTime > note.time)
|
|
continue;
|
|
|
|
total++;
|
|
|
|
if (note.sLen > Conductor.stepCrochet * 0.75) {
|
|
var len:Float = note.sLen;
|
|
while(len > 10) {
|
|
total++;
|
|
len -= Math.min(len, Conductor.stepCrochet);
|
|
}
|
|
}
|
|
}
|
|
|
|
notes.preallocate(total);
|
|
|
|
var il = 0;
|
|
|
|
var prev:Note = null;
|
|
|
|
if (strumLine.notes != null) for(note in strumLine.notes) {
|
|
if (startTime != null && startTime > note.time)
|
|
continue;
|
|
|
|
notes.members[total-(il++)-1] = prev = new Note(this, note, false, prev);
|
|
|
|
if (note.sLen > Conductor.stepCrochet * 0.75) {
|
|
var len:Float = note.sLen;
|
|
var curLen:Float = 0;
|
|
while(len > 10) {
|
|
curLen = Math.min(len, Conductor.stepCrochet);
|
|
notes.members[total-(il++)-1] = prev = new Note(this, note, true, curLen, note.sLen - len, prev);
|
|
len -= curLen;
|
|
|
|
if (prev != null && prev.sustainParent != null)
|
|
prev.sustainParent.tailCount++;
|
|
}
|
|
}
|
|
}
|
|
notes.sortNotes();
|
|
|
|
var scrollSpeed = strumLine.scrollSpeed;
|
|
if(scrollSpeed == null) if (PlayState.instance != null) scrollSpeed = PlayState.instance.scrollSpeed;
|
|
if(scrollSpeed == null) scrollSpeed = 1;
|
|
|
|
// TODO: Make this work by accounting zoom and scroll speed changes - Nex
|
|
/*var limit = FlxG.height / 0.45;
|
|
notes.limit = limit / scrollSpeed;
|
|
OR
|
|
notes.limit = Flags.DEFAULT_NOTE_MS_LIMIT / scrollSpeed;*/
|
|
}
|
|
|
|
public override function update(elapsed:Float) {
|
|
super.update(elapsed);
|
|
notes.update(elapsed);
|
|
}
|
|
|
|
public override function draw() {
|
|
super.draw();
|
|
notes.cameras = cameras;
|
|
notes.draw();
|
|
}
|
|
|
|
/**
|
|
* Updates the notes.
|
|
**/
|
|
public inline function updateNotes() {
|
|
__updateNote_songPos = Conductor.songPosition;
|
|
if(__updateNote_event == null) __updateNote_event = PlayState.instance.__updateNote_event;
|
|
notes.forEach(updateNote);
|
|
}
|
|
|
|
var __updateNote_strum:Strum;
|
|
var __updateNote_songPos:Float;
|
|
var __updateNote_event:NoteUpdateEvent;
|
|
/**
|
|
* Updates a note.
|
|
* This updates the position, state, and handles the input.
|
|
**/
|
|
public function updateNote(daNote:Note) {
|
|
__updateNote_strum = members[daNote.noteData];
|
|
if (__updateNote_strum == null) return;
|
|
|
|
__updateNote_event.recycle(daNote, FlxG.elapsed, __updateNote_strum);
|
|
onNoteUpdate.dispatch(__updateNote_event);
|
|
if (__updateNote_event.cancelled) return;
|
|
|
|
if (__updateNote_event.__updateHitWindow) {
|
|
var hitWindow = Flags.USE_LEGACY_TIMING ? PlayState.instance.hitWindow : PlayState.instance.ratingManager.lastHitWindow;
|
|
daNote.canBeHit = (daNote.strumTime > __updateNote_songPos - (hitWindow * daNote.latePressWindow)
|
|
&& daNote.strumTime < __updateNote_songPos + (hitWindow * daNote.earlyPressWindow));
|
|
|
|
if (daNote.strumTime < __updateNote_songPos - hitWindow && !daNote.wasGoodHit)
|
|
daNote.tooLate = true;
|
|
}
|
|
|
|
if (cpu && __updateNote_event.__autoCPUHit && !daNote.avoid && !daNote.wasGoodHit && daNote.strumTime < __updateNote_songPos)
|
|
PlayState.instance.goodNoteHit(this, daNote);
|
|
|
|
if (daNote.wasGoodHit && daNote.isSustainNote && daNote.strumTime + daNote.sustainLength < __updateNote_songPos && !daNote.noSustainClip) {
|
|
deleteNote(daNote);
|
|
return;
|
|
}
|
|
|
|
if (daNote.tooLate) {
|
|
if (!cpu) PlayState.instance.noteMiss(this, daNote);
|
|
else deleteNote(daNote);
|
|
return;
|
|
}
|
|
|
|
|
|
if (__updateNote_event.strum == null) return;
|
|
if (__updateNote_event.__reposNote) __updateNote_event.strum.updateNotePosition(daNote);
|
|
|
|
if (daNote.isSustainNote) {
|
|
daNote.updateSustain(__updateNote_event.strum);
|
|
}
|
|
}
|
|
|
|
var __pressed:Array<Bool> = [];
|
|
var __justPressed:Array<Bool> = [];
|
|
var __justReleased:Array<Bool> = [];
|
|
var __notePerStrum:Array<Note> = [];
|
|
|
|
function __inputProcessPressed(note:Note) {
|
|
if (__pressed[note.strumID] && note.isSustainNote && note.strumTime < __updateNote_songPos && !note.wasGoodHit && note.sustainParent.wasGoodHit) {
|
|
PlayState.instance.goodNoteHit(this, note);
|
|
}
|
|
}
|
|
function __inputProcessJustPressed(note:Note) {
|
|
var strumID = note.strumID;
|
|
if (!__justPressed[strumID] || note.isSustainNote || note.wasGoodHit || !note.canBeHit) return;
|
|
|
|
var cur = __notePerStrum[strumID];
|
|
if (cur == null) {
|
|
__notePerStrum[strumID] = note;
|
|
return;
|
|
}
|
|
|
|
var songPos = __updateNote_songPos;
|
|
var noteDist = Math.abs(note.strumTime - songPos);
|
|
|
|
var noteShouldAvoid = note.avoid;
|
|
var curShouldAvoid = cur.avoid;
|
|
if (!noteShouldAvoid && curShouldAvoid) {
|
|
__notePerStrum[strumID] = note;
|
|
return;
|
|
}
|
|
|
|
var curDist = Math.abs(cur.strumTime - songPos);
|
|
if (noteShouldAvoid == curShouldAvoid && noteDist < curDist)
|
|
__notePerStrum[strumID] = note;
|
|
}
|
|
|
|
/**
|
|
* Updates the input for the strumline, and handles the input.
|
|
* @param id The ID of the strum
|
|
**/
|
|
public function updateInput(id:Int = 0) {
|
|
updateNotes();
|
|
|
|
if (cpu) return;
|
|
|
|
final membersLength = members.length;
|
|
|
|
if (__pressed.length != membersLength) {
|
|
__pressed.resize(membersLength);
|
|
__justPressed.resize(membersLength);
|
|
__justReleased.resize(membersLength);
|
|
}
|
|
|
|
if (__notePerStrum.length != membersLength)
|
|
__notePerStrum = cast new haxe.ds.Vector(membersLength); // [for(_ in 0...members.length) null];
|
|
|
|
for (i in 0...membersLength) {
|
|
__pressed[i] = members[i].__getPressed(this);
|
|
__justPressed[i] = members[i].__getJustPressed(this);
|
|
__justReleased[i] = members[i].__getJustReleased(this);
|
|
}
|
|
|
|
var event = EventManager.get(InputSystemEvent).recycle(__pressed, __justPressed, __justReleased, this, id);
|
|
if (PlayState.instance != null) PlayState.instance.gameAndCharsEvent("onInputUpdate", event);
|
|
if (event.cancelled) return;
|
|
|
|
__pressed = CoolUtil.getDefault(event.pressed, []);
|
|
__justPressed = CoolUtil.getDefault(event.justPressed, []);
|
|
__justReleased = CoolUtil.getDefault(event.justReleased, []);
|
|
|
|
if (__pressed.contains(true)) {
|
|
if (__justPressed.contains(true)) {
|
|
notes.forEachAlive(__inputProcessJustPressed);
|
|
|
|
for (k => pr in __justPressed)
|
|
{
|
|
var note = __notePerStrum[k];
|
|
|
|
if (note != null) {
|
|
PlayState.instance.goodNoteHit(this, note);
|
|
__notePerStrum[k] = null;
|
|
} else if (pr && !ghostTapping)
|
|
PlayState.instance.noteMiss(this, null, k, ID);
|
|
}
|
|
}
|
|
|
|
for (c in characters)
|
|
if (c.lastAnimContext != DANCE)
|
|
c.__lockAnimThisFrame = true;
|
|
|
|
notes.forEachAlive(__inputProcessPressed);
|
|
}
|
|
|
|
forEach(function(str:Strum) {
|
|
str.updatePlayerInput(__pressed[str.ID], __justPressed[str.ID], __justReleased[str.ID]);
|
|
});
|
|
|
|
PlayState.instance.gameAndCharsCall("onPostInputUpdate");
|
|
}
|
|
|
|
/**
|
|
* Adds/removes health to/from the strumline.
|
|
* If the strumline is an opponent strumline, it will subtract the health, otherwise it will add the health.
|
|
* @param health The amount of health to add/remove
|
|
**/
|
|
public inline function addHealth(health:Float)
|
|
PlayState.instance.health += health * (opponentSide ? -1 : 1);
|
|
|
|
/**
|
|
* Generates strums, and adds them to the strumline.
|
|
* @param amount The amount of strums to generate (-1 for the default amount)
|
|
**/
|
|
public inline function generateStrums(amount:Int = -1) {
|
|
if(amount == -1) amount = Flags.DEFAULT_STRUM_AMOUNT;
|
|
for (i in 0...amount)
|
|
add(createStrum(i));
|
|
}
|
|
|
|
override function destroy() {
|
|
super.destroy();
|
|
if(startingPos != null)
|
|
startingPos.put();
|
|
notes = FlxDestroyUtil.destroy(notes);
|
|
}
|
|
|
|
/**
|
|
* Creates a strum and returns the created strum (needs to be added manually).
|
|
* @param i Index of the strum
|
|
* @param animPrefix (Optional) Animation prefix (`left` = `arrowLEFT`, `left press`, `left confirm`).
|
|
* @param spritePath (Optional) The sprite's graphic path if you don't want the default one.
|
|
* @param playIntroAnimation (Optional) Whenever the intro animation should be played, by default might be `true` under certain conditions.
|
|
*/
|
|
public function createStrum(i:Int, ?animPrefix:String, ?spritePath:String, ?playIntroAnimation:Bool) {
|
|
if (animPrefix == null)
|
|
animPrefix = strumAnimPrefix[i % strumAnimPrefix.length];
|
|
var babyArrow:Strum = new Strum(startingPos.x + (Note.swagWidth * strumScale * (data.strumSpacing != null ? data.strumSpacing : 1) * i), startingPos.y + (Note.swagWidth*0.5) - (Note.swagWidth * strumScale * 0.5));
|
|
babyArrow.ID = i;
|
|
babyArrow.strumLine = this;
|
|
|
|
if(data.scrollSpeed != null)
|
|
babyArrow.scrollSpeed = data.scrollSpeed;
|
|
|
|
var event = EventManager.get(StrumCreationEvent).recycle(babyArrow, PlayState.instance.strumLines.members.indexOf(this), i, animPrefix);
|
|
event.__doAnimation = playIntroAnimation == null ? (!MusicBeatState.skipTransIn && (PlayState.instance != null ? PlayState.instance.introLength > 0 : true)) : playIntroAnimation;
|
|
if (spritePath != null) event.sprite = spritePath;
|
|
if (PlayState.instance != null) event = PlayState.instance.gameAndCharsEvent("onStrumCreation", event);
|
|
|
|
if (!event.cancelled) {
|
|
babyArrow.frames = Paths.getFrames(event.sprite);
|
|
babyArrow.animation.addByPrefix('green', 'arrowUP');
|
|
babyArrow.animation.addByPrefix('blue', 'arrowDOWN');
|
|
babyArrow.animation.addByPrefix('purple', 'arrowLEFT');
|
|
babyArrow.animation.addByPrefix('red', 'arrowRIGHT');
|
|
|
|
babyArrow.antialiasing = true;
|
|
babyArrow.setGraphicSize(Std.int((babyArrow.width * Flags.DEFAULT_NOTE_SCALE) * strumScale));
|
|
|
|
babyArrow.animation.addByPrefix('static', 'arrow${event.animPrefix.toUpperCase()}');
|
|
babyArrow.animation.addByPrefix('pressed', '${event.animPrefix} press', 24, false);
|
|
babyArrow.animation.addByPrefix('confirm', '${event.animPrefix} confirm', 24, false);
|
|
}
|
|
|
|
babyArrow.cpu = cpu;
|
|
babyArrow.updateHitbox();
|
|
babyArrow.scrollFactor.set();
|
|
|
|
if (event.__doAnimation)
|
|
{
|
|
babyArrow.y -= 10;
|
|
babyArrow.alpha = 0;
|
|
FlxTween.tween(babyArrow, {y: babyArrow.y + 10, alpha: 1}, 1, {ease: FlxEase.circOut, startDelay: 0.5 + (0.2 * i * (4 / (data.keyCount != null ? data.keyCount : 4)))});
|
|
}
|
|
babyArrow.playAnim('static');
|
|
|
|
insert(i, babyArrow);
|
|
|
|
if (PlayState.instance != null) PlayState.instance.gameAndCharsEvent("onPostStrumCreation", event);
|
|
|
|
return babyArrow;
|
|
}
|
|
|
|
/**
|
|
* Deletes a note from this strumline.
|
|
* @param note Note to delete
|
|
*/
|
|
public function deleteNote(note:Note) {
|
|
if (note == null) return;
|
|
var event:SimpleNoteEvent = EventManager.get(SimpleNoteEvent).recycle(note);
|
|
onNoteDelete.dispatch(event);
|
|
if (!event.cancelled) {
|
|
if (note.isSustainNote && note.sustainParent != null && note.sustainParent.tailCount > 0)
|
|
note.sustainParent.tailCount--;
|
|
note.kill();
|
|
notes.remove(note, true);
|
|
note.destroy();
|
|
}
|
|
}
|
|
|
|
public static inline function calculateStartingXPos(hudXRatio:Float, scale:Float, spacing:Float, keyCount:Int) {
|
|
return (FlxG.width * hudXRatio) - ((Note.swagWidth * scale * ((keyCount/2)-0.5) * spacing) + Note.swagWidth * 0.5 * scale);
|
|
}
|
|
public static inline function calculateStartingXPosFromInitialWidth(hudXRatio:Float, scale:Float, spacing:Float, keyCount:Int) {
|
|
return (FlxG.initialWidth * hudXRatio) - ((Note.swagWidth * scale * ((keyCount/2)-0.5) * spacing) + Note.swagWidth * 0.5 * scale);
|
|
}
|
|
|
|
/**
|
|
* SETTERS & GETTERS
|
|
*/
|
|
#if REGION
|
|
private inline function set_cpu(b:Bool):Bool {
|
|
for(s in members)
|
|
if (s != null)
|
|
s.cpu = b;
|
|
return cpu = b;
|
|
}
|
|
private inline function set_animSuffix(str:String):String {
|
|
for(s in members)
|
|
if (s != null)
|
|
s.animSuffix = str;
|
|
return animSuffix = str;
|
|
}
|
|
private inline function set_altAnim(b:Bool):Bool {
|
|
animSuffix = b ? defaultAnimSuffix : "";
|
|
return b;
|
|
}
|
|
private inline function get_altAnim():Bool {
|
|
return animSuffix == defaultAnimSuffix;
|
|
}
|
|
#end
|
|
} |