235 lines
8.4 KiB
C#
235 lines
8.4 KiB
C#
using Cryville.Common;
|
|
using Cryville.Common.Pdt;
|
|
using Cryville.Crtr.Event;
|
|
using System.Collections.Generic;
|
|
|
|
namespace Cryville.Crtr {
|
|
public class Judge {
|
|
readonly PdtEvaluator _etor;
|
|
readonly PdtRuleset _rs;
|
|
readonly Dictionary<Identifier, float> ct
|
|
= new Dictionary<Identifier, float>();
|
|
readonly Dictionary<Identifier, List<JudgeEvent>> evs
|
|
= new Dictionary<Identifier, List<JudgeEvent>>();
|
|
readonly Dictionary<Identifier, List<JudgeEvent>> activeEvs
|
|
= new Dictionary<Identifier, List<JudgeEvent>>();
|
|
struct JudgeEvent {
|
|
public float StartTime { get; set; }
|
|
public float EndTime { get; set; }
|
|
public float StartClip { get; set; }
|
|
public float EndClip { get; set; }
|
|
public JudgeDefinition Definition { get; set; }
|
|
public ContainerState State { get; set; }
|
|
}
|
|
static readonly IComparer<JudgeEvent> _stcmp = new JudgeEventStartTimeComparer();
|
|
class JudgeEventStartTimeComparer : IComparer<JudgeEvent> {
|
|
public int Compare(JudgeEvent x, JudgeEvent y) {
|
|
return x.StartClip.CompareTo(y.StartClip);
|
|
}
|
|
}
|
|
public Judge(PdtRuleset rs) {
|
|
_etor = ChartPlayer.etor;
|
|
_rs = rs;
|
|
foreach (var s in rs.scores) {
|
|
var key = s.Key;
|
|
scoreSrcs.Add(key.Key, new PropSrc.Float(() => scores[key.Key]));
|
|
scoreOps.Add(key.Key, new PropOp.Float(v => scores[key.Key] = v));
|
|
scoreFmtKeys.Add(key.Key, IdentifierManager.SharedInstance.Request("_score_" + (string)key.Name));
|
|
scoreDefs.Add(key.Key, s.Value);
|
|
scores.Add(key.Key, s.Value.init);
|
|
}
|
|
}
|
|
public void Prepare(float st, float et, Identifier input, JudgeDefinition def, ContainerState container) {
|
|
List<JudgeEvent> list;
|
|
if (!evs.TryGetValue(input, out list)) {
|
|
ct.Add(input, 0);
|
|
evs.Add(input, list = new List<JudgeEvent>());
|
|
activeEvs.Add(input, new List<JudgeEvent>());
|
|
}
|
|
var ev = new JudgeEvent {
|
|
StartTime = st,
|
|
EndTime = et,
|
|
StartClip = st + def.clip[0],
|
|
EndClip = et + def.clip[1],
|
|
Definition = def,
|
|
State = container,
|
|
};
|
|
var index = list.BinarySearch(ev, _stcmp);
|
|
if (index < 0) index = ~index;
|
|
list.Insert(index, ev);
|
|
}
|
|
static bool _flag;
|
|
static readonly PropOp.Boolean _flagop = new PropOp.Boolean(v => _flag = v);
|
|
static readonly int _var_fn = IdentifierManager.SharedInstance.Request("fn");
|
|
static readonly int _var_tn = IdentifierManager.SharedInstance.Request("tn");
|
|
static readonly int _var_ft = IdentifierManager.SharedInstance.Request("ft");
|
|
static readonly int _var_tt = IdentifierManager.SharedInstance.Request("tt");
|
|
readonly byte[] _numbuf1 = new byte[sizeof(float)];
|
|
readonly byte[] _numbuf2 = new byte[sizeof(float)];
|
|
readonly byte[] _numbuf3 = new byte[sizeof(float)];
|
|
readonly byte[] _numbuf4 = new byte[sizeof(float)];
|
|
unsafe void LoadNum(byte[] buffer, float value) {
|
|
fixed (byte* ptr = buffer) *(float*)ptr = value;
|
|
}
|
|
// Adopted from System.Collections.Generic.ArraySortHelper<T>.InternalBinarySearch(T[] array, int index, int length, T value, IComparer<T> comparer)
|
|
int BinarySearch(List<JudgeEvent> list, float time, int stack) {
|
|
int num = 0;
|
|
int num2 = list.Count - 1;
|
|
while (num <= num2) {
|
|
int num3 = num + (num2 - num >> 1);
|
|
int num4 = -list[num3].Definition.stack.CompareTo(stack);
|
|
if (num4 == 0) num4 = list[num3].StartClip.CompareTo(time);
|
|
if (num4 == 0) return num3;
|
|
else if (num4 < 0) num = num3 + 1;
|
|
else num2 = num3 - 1;
|
|
}
|
|
return ~num;
|
|
}
|
|
int BinarySearchFirst(List<JudgeEvent> list, float time, int stack) {
|
|
if (list[0].Definition.stack == stack && list[0].StartClip == time) return 0;
|
|
int num = 0;
|
|
int num2 = list.Count - 1;
|
|
while (num <= num2) {
|
|
int num3 = num + (num2 - num >> 1);
|
|
int num4 = -list[num3].Definition.stack.CompareTo(stack);
|
|
if (num4 == 0) num4 = list[num3].StartClip.CompareTo(time);
|
|
if (num4 >= 0) num2 = num3 - 1;
|
|
else num = num3 + 1;
|
|
}
|
|
return num + 1;
|
|
}
|
|
public void Feed(Identifier target, float ft, float tt) {
|
|
Forward(target, tt);
|
|
var actlist = activeEvs[target];
|
|
if (actlist.Count > 0) {
|
|
LoadNum(_numbuf3, ft); _etor.ContextCascadeUpdate(_var_ft, new PropSrc.Arbitrary(PdtInternalType.Number, _numbuf3));
|
|
LoadNum(_numbuf4, tt); _etor.ContextCascadeUpdate(_var_tt, new PropSrc.Arbitrary(PdtInternalType.Number, _numbuf4));
|
|
var index = 0;
|
|
while (index >= 0 && index < actlist.Count) {
|
|
var ev = actlist[index];
|
|
LoadNum(_numbuf1, ev.StartTime); _etor.ContextCascadeUpdate(_var_fn, new PropSrc.Arbitrary(PdtInternalType.Number, _numbuf1));
|
|
LoadNum(_numbuf2, ev.EndTime); _etor.ContextCascadeUpdate(_var_tn, new PropSrc.Arbitrary(PdtInternalType.Number, _numbuf2));
|
|
var def = ev.Definition;
|
|
if (def.hit != null) _etor.Evaluate(_flagop, def.hit);
|
|
else _flag = true;
|
|
if (_flag) {
|
|
if (def.scores != null) UpdateScore(def.scores);
|
|
if (def.pass != null) Pass(def.pass);
|
|
actlist.RemoveAt(index);
|
|
if (def.prop != 0 && actlist.Count > 0) {
|
|
index = BinarySearchFirst(actlist, ev.StartClip, def.stack - def.prop);
|
|
if (index < 0) index = ~index;
|
|
}
|
|
else index++;
|
|
}
|
|
else index++;
|
|
}
|
|
}
|
|
}
|
|
bool Pass(Identifier[] ids) {
|
|
foreach (var i in ids) {
|
|
var def = _rs.judges[i];
|
|
if (def.hit != null) _etor.Evaluate(_flagop, def.hit);
|
|
else _flag = true;
|
|
if (_flag) {
|
|
if (def.scores != null) UpdateScore(def.scores);
|
|
if (def.pass != null) Pass(def.pass);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
public void Cleanup(Identifier target, float ft, float tt) {
|
|
Forward(target, tt);
|
|
var actlist = activeEvs[target];
|
|
for (int i = actlist.Count - 1; i >= 0; i--) {
|
|
JudgeEvent ev = actlist[i];
|
|
if (tt > ev.EndClip) {
|
|
actlist.RemoveAt(i);
|
|
if (ev.Definition.miss != null) Pass(ev.Definition.miss);
|
|
}
|
|
}
|
|
}
|
|
void Forward(Identifier target, float tt) {
|
|
var list = evs[target];
|
|
var actlist = activeEvs[target];
|
|
JudgeEvent ev;
|
|
while (list.Count > 0 && (ev = list[0]).StartClip <= tt) {
|
|
list.RemoveAt(0);
|
|
var index = BinarySearch(actlist, ev.StartClip, ev.Definition.stack);
|
|
if (index < 0) index = ~index;
|
|
actlist.Insert(index, ev);
|
|
}
|
|
}
|
|
void UpdateScore(Dictionary<ScoreOperation, PdtExpression> scoreops) {
|
|
foreach (var scoreop in scoreops) {
|
|
var key = scoreop.Key;
|
|
_etor.ContextSelfValue = scoreSrcs[key.name.Key];
|
|
_etor.Evaluate(scoreOps[key.name.Key], scoreop.Value);
|
|
scoreSrcs[key.name.Key].Invalidate();
|
|
foreach (var s in _rs.scores) {
|
|
if (s.Value.value != null) {
|
|
_etor.ContextSelfValue = scoreSrcs[s.Key.Key];
|
|
_etor.Evaluate(scoreOps[s.Key.Key], s.Value.value);
|
|
scoreSrcs[s.Key.Key].Invalidate();
|
|
}
|
|
}
|
|
}
|
|
ScoreCache.Clear();
|
|
}
|
|
readonly Dictionary<int, int> scoreFmtKeys = new Dictionary<int, int>();
|
|
readonly Dictionary<int, PropSrc> scoreSrcs = new Dictionary<int, PropSrc>();
|
|
readonly Dictionary<int, PropOp> scoreOps = new Dictionary<int, PropOp>();
|
|
readonly Dictionary<int, ScoreDefinition> scoreDefs = new Dictionary<int, ScoreDefinition>();
|
|
public readonly Dictionary<int, float> scores = new Dictionary<int, float>();
|
|
readonly Dictionary<int, string> ScoreCache = new Dictionary<int, string>();
|
|
readonly object _lock = new object();
|
|
public Dictionary<int, string> GetFormattedScoreStrings() {
|
|
lock (_lock) {
|
|
if (ScoreCache.Count == 0) {
|
|
foreach (var s in scores)
|
|
ScoreCache.Add(scoreFmtKeys[s.Key], s.Value.ToString(scoreDefs[s.Key].format));
|
|
}
|
|
return ScoreCache;
|
|
}
|
|
}
|
|
public string GetFullFormattedScoreString() {
|
|
bool flag = false;
|
|
string result = "";
|
|
foreach (var s in GetFormattedScoreStrings()) {
|
|
result += string.Format(flag ? "\n{0}: {1}" : "{0}: {1}", IdentifierManager.SharedInstance.Retrieve(s.Key), s.Value);
|
|
flag = true;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
public class InputDefinition {
|
|
public int dim;
|
|
public bool notnull;
|
|
public Dictionary<Identifier, PdtExpression> pass;
|
|
}
|
|
public class JudgeDefinition {
|
|
public float[] clip;
|
|
public PdtExpression input;
|
|
public PdtExpression hit;
|
|
public Identifier[] pass;
|
|
public Identifier[] miss;
|
|
public Dictionary<ScoreOperation, PdtExpression> scores;
|
|
public int stack;
|
|
public int prop = 1;
|
|
}
|
|
public class ScoreOperation {
|
|
public Identifier name;
|
|
public Identifier op;
|
|
public override string ToString() {
|
|
if (op == default(Identifier)) return name.ToString();
|
|
else return string.Format("{0} {1}", name, op);
|
|
}
|
|
}
|
|
public class ScoreDefinition {
|
|
public PdtExpression value;
|
|
public float init = 0;
|
|
public string format = "";
|
|
}
|
|
}
|