298 lines
9.1 KiB
C#
298 lines
9.1 KiB
C#
using Cryville.Common.Math;
|
|
using Cryville.Crtr.Components;
|
|
using Cryville.Crtr.Event;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using UnityEngine;
|
|
|
|
namespace Cryville.Crtr {
|
|
class NoteHandler : ContainerHandler {
|
|
readonly GroupHandler gh;
|
|
public readonly Chart.Note Event;
|
|
readonly Judge judge;
|
|
public NoteHandler(GroupHandler gh, Chart.Note ev, Judge j) : base() {
|
|
this.gh = gh;
|
|
Event = ev;
|
|
judge = j;
|
|
}
|
|
|
|
public override string TypeName {
|
|
get {
|
|
return "note";
|
|
}
|
|
}
|
|
|
|
/*public override void Dispose() {
|
|
base.Dispose();
|
|
for (int i = notePool.Count - 1; i >= 0; i--) {
|
|
var t = notePool.ElementAt(i);
|
|
GameObject.Destroy(t.Value);
|
|
}
|
|
}*/
|
|
|
|
//Dictionary<StampedEvent, GameObject> notePool = new Dictionary<StampedEvent, GameObject>();
|
|
|
|
// Trail trail;
|
|
SectionalGameObject[] sgos;
|
|
|
|
public override void Init() {
|
|
base.Init();
|
|
sgos = gogroup.GetComponentsInChildren<SectionalGameObject>();
|
|
}
|
|
protected override void PreAwake(ContainerState s) {
|
|
base.PreAwake(s);
|
|
/*var attev = StampedEvent.AttackEvent;
|
|
if (attev != null) {
|
|
GameObject headObj = null;
|
|
bool pooledh = notePool.TryGetValue(attev, out headObj);
|
|
if (pooledh)
|
|
GameObject.Destroy(headObj);
|
|
}*/
|
|
#if UNITY_5_6_OR_NEWER
|
|
a_head.SetPositionAndRotation(Position = GetFramePoint(s.Parent, s.Track), Rotation = GetFrameRotation(s.Parent, s.Track));
|
|
#else
|
|
a_head.position = Position = GetFramePoint(s.Parent, s.Track);
|
|
a_head.rotation = Rotation = GetFrameRotation(s.Parent, s.Track);
|
|
#endif
|
|
}
|
|
protected override void Awake(ContainerState s) {
|
|
base.Awake(s);
|
|
if (!gogroup) return;
|
|
Chart.Note tev = Event;
|
|
if (tev.IsLong) {
|
|
foreach (var i in sgos) {
|
|
i.Reset();
|
|
i.AppendPoint(Position, Rotation);
|
|
}
|
|
}
|
|
else {
|
|
#if UNITY_5_6_OR_NEWER
|
|
gogroup.SetPositionAndRotation(Position, Rotation);
|
|
#else
|
|
gogroup.position = Position;
|
|
gogroup.rotation = Rotation;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
readonly Dictionary<Chart.Motion, Vec1> phMotions = new Dictionary<Chart.Motion, Vec1>();
|
|
bool invalidated = false;
|
|
readonly List<StampedEvent.Judge> patchedJudgeEvents = new List<StampedEvent.Judge>();
|
|
|
|
public override void StartUpdate(ContainerState s) {
|
|
base.StartUpdate(s);
|
|
if (s.CloneType == 16 && Event.judge != null) {
|
|
// var etor = new Evaluator();
|
|
//CompiledRuleset.PatchJudge(Event, ChartPlayer.cruleset.primary_judges[Event.judge], s.Time, etor, patchedJudgeEvents, !Event.@long);
|
|
}
|
|
}
|
|
|
|
public override void Update(ContainerState s, StampedEvent ev) {
|
|
base.Update(s, ev);
|
|
if (s.CloneType == 1) {
|
|
Position = GetFramePoint(bs.Parent, bs.Track);
|
|
Rotation = GetFrameRotation(bs.Parent, bs.Track);
|
|
}
|
|
else if (s.CloneType == 2) {
|
|
/*for (int i = notePool.Count - 1; i >= 0; i--) {
|
|
var t = notePool.ElementAt(i);
|
|
var eev = t.Key;
|
|
var rev = t.Key.ReleaseEvent;
|
|
if (rev != null) {
|
|
eev = rev;
|
|
}
|
|
if (eev.Time < cs.Time) {
|
|
GameObject.Destroy(t.Value);
|
|
notePool.Remove(t.Key);
|
|
}
|
|
}*/
|
|
Position = GetFramePoint(ts.Parent, ts.Track);
|
|
Rotation = GetFrameRotation(ts.Parent, ts.Track);
|
|
if (!gogroup) return;
|
|
// sgos = gogroup.GetComponentsInChildren<PolygonSGO>();
|
|
Chart.Note tev = Event;
|
|
if (tev.IsLong) {
|
|
foreach (var i in sgos)
|
|
i.AppendPoint(Position, Rotation);
|
|
}
|
|
/*else {
|
|
gogroup.position = p;
|
|
gogroup.rotation = Quaternion.Euler(ts.Direction);
|
|
}*/
|
|
}
|
|
else if (s.CloneType == 16) {
|
|
if (ev == null) { }
|
|
else if (ev.Unstamped == null) { }
|
|
else if (ev.Unstamped is Chart.Motion) {
|
|
var tev = (Chart.Motion)ev.Unstamped;
|
|
if (tev.Name.MainName != "judge") return;
|
|
phMotions.Add(tev, (Vec1)s.GetRawValue<Vec1>(tev.Name).Clone());
|
|
}
|
|
else if (ev.Unstamped is InstantEvent) {
|
|
var oev = ((InstantEvent)ev.Unstamped).Original;
|
|
if (oev is Chart.Motion) {
|
|
var tev = (Chart.Motion)oev;
|
|
if (tev.Name.MainName != "judge") return;
|
|
var v0 = phMotions[tev];
|
|
var v1 = s.GetRawValue<Vec1>(tev.Name);
|
|
// var etor = new Evaluator();
|
|
for (var vi = Mathf.Ceil(v0.Value); vi < v1.Value; vi++) {
|
|
var v = new Vec1(vi);
|
|
var t = MotionLerper.Delerp(v, ev.Time, v1, ev.Origin.Time, v0, tev.transition, tev.rate);
|
|
/*CompiledRuleset.PatchJudge(
|
|
Event, ChartPlayer.cruleset.primary_judges[tev.Name.SubName],
|
|
t, etor, patchedJudgeEvents
|
|
);*/
|
|
}
|
|
phMotions.Remove(tev);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public override void ExUpdate(ContainerState s, StampedEvent ev) {
|
|
base.ExUpdate(s, ev);
|
|
if (ev is StampedEvent.Judge) {
|
|
var tev = (StampedEvent.Judge)ev;
|
|
if (tev.TargetJudge != null && s.CloneType == 0 && !invalidated) {
|
|
//judge.Issue(tev, this);
|
|
}
|
|
else if (tev.TargetJudge == null && s.CloneType == 17) {
|
|
//judge.RecordPos(tev.StartEvent, GetFramePoint(s.Parent, s.Track));
|
|
}
|
|
else
|
|
return;
|
|
patchedJudgeEvents.Remove(tev);
|
|
// Logger.Log("main", 0, "Judge", "ir {0}", patchedJudgeEvents.Count);
|
|
}
|
|
}
|
|
|
|
public override void MotionUpdate(byte ct, Chart.Motion ev) {
|
|
base.MotionUpdate(ct, ev);
|
|
if (ct == 0) {
|
|
if (ev.Name.MainName == "judge") {
|
|
if (invalidated) return;
|
|
if (ev.Name.SubName == null)
|
|
throw new InvalidOperationException();
|
|
// judge.IssueImmediate(this, ev.Name.SubName, GetFramePoint(cs.Parent, cs.Track));
|
|
}
|
|
}
|
|
else if (ct == 16) {
|
|
/*var etor = new EvalImpl();
|
|
if (ev.MotionName == "judge") {
|
|
if (ev.MotionSubName == null)
|
|
throw new InvalidOperationException();
|
|
var l = new List<StampedEvent>();
|
|
float t = ps.Time;
|
|
CompiledRuleset.PatchJudge(
|
|
Event, ChartPlayer.cruleset.primary_judges[ev.MotionSubName],
|
|
t, etor, ref l
|
|
);
|
|
cs.Bus.IssueEventPatch(l);
|
|
}*/
|
|
}
|
|
}
|
|
|
|
public override void EndUpdate(ContainerState s) {
|
|
if (s.CloneType == 0 || s.CloneType == 2) {
|
|
if (!gogroup) goto return_ahead;
|
|
// sgos = gogroup.GetComponentsInChildren<PolygonSGO>();
|
|
foreach (var i in sgos) i.Seal();
|
|
#if UNITY_5_6_OR_NEWER
|
|
a_tail.SetPositionAndRotation(GetFramePoint(ts.Parent, ts.Track), Quaternion.Euler(ts.Direction));
|
|
#else
|
|
a_tail.position = GetFramePoint(ts.Parent, ts.Track);
|
|
a_tail.rotation = Quaternion.Euler(ts.Direction);
|
|
#endif
|
|
}
|
|
else if (s.CloneType == 16) {
|
|
if (Event.endjudge != null) {
|
|
//var etor = new Evaluator();
|
|
//CompiledRuleset.PatchJudge(Event, ChartPlayer.cruleset.primary_judges[Event.endjudge], ps.Time, etor, patchedJudgeEvents, true);
|
|
}
|
|
cs.Bus.IssuePatch(patchedJudgeEvents.Cast<StampedEvent>());
|
|
}
|
|
return_ahead:
|
|
OpenAnchor("tail");
|
|
base.EndUpdate(s);
|
|
CloseAnchor("tail");
|
|
}
|
|
|
|
Vector3 GetFramePoint(ContainerState state, float track) {
|
|
return GetFrame(state, track, th => ((TrackHandler)th.Handler).GetCurrentWorldPoint());
|
|
}
|
|
|
|
Quaternion GetFrameRotation(ContainerState state, float track) {
|
|
var r = GetFrame(state, track, th => Quaternion.Euler(th.Direction) * Vector3.forward);
|
|
return Quaternion.LookRotation(r, state.Normal);
|
|
}
|
|
|
|
Vector3 GetFrame(ContainerState state, float track, Func<ContainerState, Vector3> func) {
|
|
// TODO
|
|
int id = Mathf.FloorToInt(track);
|
|
var ts0 = state.GetChild(id, typeof(Chart.Track));
|
|
var p1 = func(ts0);
|
|
if (track == id)
|
|
return p1;
|
|
var ts1 = state.GetChild(id + 1, typeof(Chart.Track));
|
|
var p2 = func(ts1);
|
|
bool c0 = ts0.Corner;
|
|
bool c1 = ts1.Corner;
|
|
float t = track - id;
|
|
float deltaz = p2.z - p1.z;
|
|
float nt = 1 - t;
|
|
if (c0 && c1)
|
|
return (1 - t) * p1 + t * p2;
|
|
else {
|
|
var ctrl = new List<Vector3>(2);
|
|
if (!c0) {
|
|
var tp = ts0.GetControlPoint(true, deltaz);
|
|
if (tp != Vector3.zero) ctrl.Add(tp);
|
|
}
|
|
if (!c1) {
|
|
var tp = ts1.GetControlPoint(false, -deltaz);
|
|
if (tp != Vector3.zero) ctrl.Add(tp);
|
|
}
|
|
if (ctrl.Count == 0) {
|
|
/* // Early algorithm
|
|
Vector3 m0, m1;
|
|
bool flag0 = id == 0;
|
|
bool flag1 = id == state.Children.Where(i => i.Key.Event is Chart.Track).Count() - 2;
|
|
if (flag0 && flag1) // Only two tracks exist
|
|
return (1 - t) * p1 + t * p2;
|
|
else {
|
|
Vector3 p0, p3;
|
|
if (!flag1) p3 = ((TrackHandler)tl.ElementAt(id + 2).Value.Handler).GetCurrentWorldPoint();
|
|
if (!flag0) p0 = ((TrackHandler)tl.ElementAt(id - 1).Value.Handler).GetCurrentWorldPoint();
|
|
if (flag0) m0 = 2 * (p2-p1).normalized - (p3-p1).normalized;
|
|
else m0 = 1f*((p1-p0).normalized + (p2-p1).normalized);
|
|
if (flag1) m1 = 2 * (p2-p1).normalized - (p2-p0).normalized;
|
|
else m1 = 1f*((p2-p1).normalized + (p3-p2).normalized);
|
|
return t*t*(2*t-3)*(p1-p2)+p1 + t*(t-1)*((t-1)*m0+t*m1);
|
|
}*/
|
|
var frame = gh.GetCurrentFrame(func);
|
|
return frame.Dot(
|
|
ColumnVector<float>.WithPolynomialCoefficients(
|
|
frame.Size, track
|
|
),
|
|
new Vector3Operator()
|
|
);
|
|
}
|
|
else if (ctrl.Count == 1) {
|
|
return nt * (nt * p1 + t * (ctrl[0] + p1)) + t * t * p2;
|
|
}
|
|
else {
|
|
var t2 = t * t;
|
|
return nt * (nt * (nt * p1 + t * (ctrl[0] + p1)) + t2 * (ctrl[1] + p1)) + t2 * t * p2;
|
|
}
|
|
}
|
|
}
|
|
|
|
public List<StampedEvent.Judge> Invalidate() {
|
|
invalidated = true;
|
|
return patchedJudgeEvents;
|
|
}
|
|
}
|
|
}
|