private void Sync()
{
// Fase1: Verwijderen van overbodige scores,
// dit zijn scores van players die niet meer in het scoreboard zitten
foreach (Score score in this.AccumulatedScores)
{
var player = score.Player;
if (!this.Players.Contains(player))
{
// verwijder participants die al een statistic hebben
score.Delete();
}
}
// Fase2: creeer score voor de players die nog geen score hebben
foreach (Person player in this.Players)
{
var scores = this.AccumulatedScores.ToArray();
var score = scores.FirstOrDefault(v => v.Player == player);
if (score == null)
{
score = new ScoreBuilder(this.strategy.Session).Build();
((ScoreDerivedRoles)score).Player = player;
this.AddAccumulatedScore(score);
}
}
}
public IActionResult FilterData([FromBody] FilterRequest request)
{
try
{
var validateResult = ValidateRequest(request.Data);
if (validateResult != null)
{
return(validateResult);
}
BaseResponse response = new BaseResponse();
ScoreBuilder scoreBuilder = new ScoreBuilder();
bool isDatePresent = false;
bool isGroupPresent = false;
bool isTeamNamePresent = false;
DateTime dateFrom = new DateTime();
DateTime dateTo = new DateTime();
if (!string.IsNullOrEmpty(request.DateFrom) && !string.IsNullOrEmpty(request.DateTo))
{
isDatePresent = true;
dateFrom = DateTime.Parse(request.DateFrom);
dateTo = DateTime.Parse(request.DateTo);
if (dateFrom > dateTo)
{
response.Success = false;
response.ExceptionObject = new Exception("DateFrom can't have greater value than DateTo.");
return(BadRequest(response));
}
}
if (!string.IsNullOrEmpty(request.Group))
{
isGroupPresent = true;
}
if (!string.IsNullOrEmpty(request.TeamName))
{
isTeamNamePresent = true;
}
GroupScoreCounter groupScoreCounter = new GroupScoreCounter(scoreBuilder.BuildScores(request.Data));
var result = groupScoreCounter.FilterData(dateFrom, dateTo, request.Group, request.TeamName, isDatePresent,
isGroupPresent, isTeamNamePresent);
response.Success = true;
response.Result = result;
return(Ok(response));
}
catch (Exception e)
{
return(BadRequest(e));
}
}
private void Sync()
{
// Phase1: Removing unnecessary scores, these are scores from players who are no longer in the scoreboard
foreach (Score score in this.AccumulatedScores)
{
var player = score.Player;
if (!this.Players.Contains(player))
{
// Remove participants who already have a statistic
score.Delete();
}
}
// Phase2: Create score for the players who don't have a score yet
foreach (Person player in this.Players)
{
var scores = this.AccumulatedScores.ToArray();
var score = scores.FirstOrDefault(v => v.Player == player);
if (score == null)
{
score = new ScoreBuilder(this.strategy.Session).Build();
((ScoreDerivedRoles)score).Player = player;
this.AddAccumulatedScore(score);
}
}
}
public MusicModule()
{
var metrics = new StavesMetrics(halfSpace: 8.0, staffLineThickness: 1.5);
//var layout = CreateTestLayoutEngine(metrics);
Layout = CreateLayoutEngine(metrics);
ScoreBuilder = CreateScoreBuilder();
}
public DrillViewModel(
MusicDrawingBuilder musicDrawingBuilder,
DrillQuiz drillQuiz,
ScoreBuilder scoreBuilder,
ScoreLayoutAlgorithm layout)
{
MusicDrawingBuilder = musicDrawingBuilder;
DrillQuiz = drillQuiz;
ScoreBuilder = scoreBuilder;
Layout = layout;
}
private Task[] ExecSortedSetAdd(Guid eventId, AuditEvent auditEvent)
{
if (ScoreBuilder == null)
{
throw new ArgumentException("The score builder was not provided");
}
var score = ScoreBuilder.Invoke(auditEvent);
auditEvent.CustomFields[RedisEventIdField] = eventId;
var tasks = new List <Task>();
var key = GetKey(auditEvent);
var value = GetValue(auditEvent);
var batch = GetDatabase(auditEvent).CreateBatch();
tasks.Add(batch.SortedSetAddAsync(key, value, score));
if (TimeToLive.HasValue)
{
tasks.Add(batch.KeyExpireAsync(key, TimeToLive));
}
// trim by scores
if (MinScoreBuilder != null)
{
double stop = MinScoreBuilder.Invoke(auditEvent);
var exclude = MinScoreExclusive ? Exclude.None : Exclude.Stop;
tasks.Add(batch.SortedSetRemoveRangeByScoreAsync(key, double.NegativeInfinity, stop, exclude));
}
if (MaxScoreBuilder != null)
{
double start = MaxScoreBuilder.Invoke(auditEvent);
var exclude = MaxScoreExclusive ? Exclude.None : Exclude.Start;
tasks.Add(batch.SortedSetRemoveRangeByScoreAsync(key, start, double.PositiveInfinity, exclude));
}
// trim by ranks
if (MaxRankBuilder != null)
{
long max = MaxRankBuilder.Invoke(auditEvent);
if (max > 0)
{
tasks.Add(batch.SortedSetRemoveRangeByRankAsync(key, 0, -(max + 1)));
}
else
{
tasks.Add(batch.SortedSetRemoveRangeByRankAsync(key, -max, -1));
}
}
OnBatchExecuting(batch, tasks, auditEvent);
batch.Execute();
return(tasks.ToArray());
}
public TestScores(ScoreBuilder scoreBuilder)
{
ScoreBuilder = scoreBuilder;
SimpleTestPhraseScore = ScoreBuilder.FromMelodicPhrase(SimpleTestPhrase);
EightNotePhraseScore = ScoreBuilder.FromMelodicPhrase(EighthNotePhrase);
var chordPhrase = ChordsPhrase.Select(chords => (chords, Duration.Quarter));
ChordPhraseScore = ScoreBuilder.FromChordsPhrase(chordPhrase);
Scores = new Dictionary <string, IReadOnlyDictionary <Beat, BeatGroup> >
{
{ "simple-test-phrase", SimpleTestPhraseScore },
{ "eight-note-phrase", EightNotePhraseScore },
{ "diatonic-chord-phrase", ChordPhraseScore }
};
}
public async Task <IActionResult> AddNewOrUpdateScores([FromBody] GroupScoresRequest request)
{
BaseResponse response = new BaseResponse();
if (!ModelState.IsValid)
{
response.Success = false;
response.ExceptionObject = new Exception(NotValidRequest, new Exception(ModelState.Values.First().Errors.First().ErrorMessage));
return(BadRequest(response));
}
try
{
ScoresDatabase scoresDatabase = new ScoresDatabase(_context);
var validateResult = ValidateRequest(request.Data);
if (validateResult != null)
{
return(validateResult);
}
ScoreBuilder scoreBuilder = new ScoreBuilder();
scoresDatabase.AddNewOrUpdateScores(scoreBuilder.BuildScores(request.Data));
await _context.SaveChangesAsync();
var scores = scoresDatabase.GetAllFromTheTableScore().ToList();
if (scores.Any())
{
GroupScoreCounter groupScoreCounter = new GroupScoreCounter(scores);
IDictionary <string, IDictionary <string, int> > groupResults =
groupScoreCounter.SortListAccordingGroup(request.RetrieveGroups);
response.Result = groupResults;
}
response.Success = true;
return(Ok(response));
}
catch (Exception e)
{
response.Success = false;
response.ExceptionObject = e;
return(BadRequest(response));
}
}
private void Sync()
{
if (this.ExistScoreboardWhereGame)
{
var players = new List <Person>(this.ScoreboardWhereGame.Players);
// Fase1: Verwijderen van overbodige statistics en
// bijhouden van participants zonder statistics
foreach (Score score in this.Scores)
{
var player = score.Player;
if (players.Contains(player))
{
// verwijder participants die al een statistic hebben
players.Remove(player);
}
else
{
// delete statistic waarvan de participant niet meer voorkomt
score.Delete();
}
}
// Fase2: creeer statistics voor de participants die nog geen
// statistic hadden
foreach (var player in players)
{
var score = new ScoreBuilder(this.strategy.Session)
.Build();
((ScoreDerivedRoles)score).Player = player;
this.AddScore(score);
}
}
else
{
foreach (Score score in this.Scores)
{
score.Delete();
}
}
}
private void Sync()
{
if (this.ExistScoreboardWhereGame)
{
var players = new List <Person>(this.ScoreboardWhereGame.Players);
// Phase1: Removing unnecessary statistics and keeping track of participants without statistics
foreach (Score score in this.Scores)
{
var player = score.Player;
if (players.Contains(player))
{
// Remove participants who already have a statistic
players.Remove(player);
}
else
{
// Delete statistic of which the participant no longer occurs
score.Delete();
}
}
// Phase2: Create statistics for the participants who did not have a statistic yet
foreach (var player in players)
{
var score = new ScoreBuilder(this.strategy.Session)
.Build();
((ScoreDerivedRoles)score).Player = player;
this.AddScore(score);
}
}
else
{
foreach (Score score in this.Scores)
{
score.Delete();
}
}
}
public IActionResult CalculateStatisticsForResults([FromBody] GroupScoresRequest request)
{
BaseResponse response = new BaseResponse();
if (!ModelState.IsValid)
{
response.Success = false;
response.ExceptionObject = new Exception(NotValidRequest, new Exception(ModelState.Values.First().Errors.First().ErrorMessage));
return(BadRequest(response));
}
try
{
var validateResult = ValidateRequest(request.Data);
if (validateResult != null)
{
return(validateResult);
}
ScoreBuilder scoreBuilder = new ScoreBuilder();
GroupScoreCounter groupScoreCounter = new GroupScoreCounter(scoreBuilder.BuildScores(request.Data));
IList <ChampionsLeagueModel> championsLeague = groupScoreCounter.CalculateStatistics(request.RetrieveGroups);
response.Success = true;
response.Result = championsLeague;
return(Ok(response));
}
catch (Exception e)
{
response.Success = false;
response.ExceptionObject = e;
return(BadRequest(response));
}
}
public void SetUp()
{
_gameScorer = new GameScorer(new Player("Player 1"), new Player("Player 2"));
_scoreBuilder = new ScoreBuilder(_gameScorer);
}
static int RunPlayDirect(PlayDirectOptions options)
{
var engine = new DesktopEngine();
var midiAccess = MidiAccessManager.Default;
foreach (var input in options.MidiInputs)
{
var foundMidiInput = midiAccess.Inputs.Where(x => x.Name.ToLower().Contains(input.ToLower()) || x.Id.ToLower().Contains(input.ToLower())).FirstOrDefault();
if (foundMidiInput == null)
{
Console.Error.WriteLine($"Did not find any MIDI input partially matching '{input}'.");
return(1);
}
else
{
Console.WriteLine($"Using MIDI input '{foundMidiInput.Name}'.");
}
engine.MidiInputs.Add(midiAccess.OpenInputAsync(foundMidiInput.Id).Result);
}
foreach (var output in options.MidiOutputs)
{
var foundMidiOutput = midiAccess.Outputs.Where(x => x.Name.ToLower().Contains(output.ToLower()) || x.Id.ToLower().Contains(output.ToLower())).FirstOrDefault();
if (foundMidiOutput == null)
{
Console.Error.WriteLine($"Did not find any MIDI output partially matching '{output}'.");
return(1);
}
else
{
Console.WriteLine($"Using MIDI output'{foundMidiOutput.Name}'.");
}
engine.MidiOutputs.Add(midiAccess.OpenOutputAsync(foundMidiOutput.Id).Result);
}
var scoreFilePath = options.FilePath;
FileStream fileStream = null;
ScoreBuilder scoreBuilder = null;
Score score = null;
Dictionary <byte, byte> noteVelocityMap = new Dictionary <byte, byte>();
foreach (var index in Enumerable.Range(0, 128))
{
noteVelocityMap.Add((byte)index, 0);
}
var lastNoteOnVelocities = new Queue <decimal>(3);
if (scoreFilePath != null)
{
if (!File.Exists(options.FilePath))
{
Console.Error.WriteLine($"Could not find sheet music file '{options.FilePath}'.");
return(1);
}
try
{
fileStream = new FileStream(scoreFilePath, FileMode.Open);
}
catch (Exception ex)
{
Console.Error.WriteLine($"Could not open sheet music file path {scoreFilePath}: {ex}");
}
if (fileStream == null)
{
return(2);
}
try
{
scoreBuilder = new ScoreBuilder(fileStream);
score = scoreBuilder.Build();
}
catch (Exception ex)
{
Console.Error.WriteLine($"Could not build sheet music score from file path {scoreFilePath}: {ex}");
}
if (scoreBuilder == null || score == null)
{
return(3);
}
else
{
Console.WriteLine($"Successfully loaded sheet music at {scoreFilePath}.");
}
engine.Interpreter.SetScore(score, scoreFilePath);
}
foreach (var midiInput in engine.MidiInputs)
{
midiInput.MessageReceived += (object sender, MidiReceivedEventArgs e) =>
{
switch (e.Data[0])
{
case MidiEvent.NoteOff:
{
var pitch = e.Data[1];
Console.WriteLine($"Off (actual): {pitch}");
engine.Interpreter.Input(new NoteRelease()
{
Pitch = pitch
});
}
break;
case MidiEvent.NoteOn:
{
var pitch = e.Data[1];
var velocity = e.Data[2];
var isSimulatedNoteOff = velocity == 0;
var isRequestedPitchAlreadyAtZeroVelocity = noteVelocityMap[pitch] == 0;
var isRequestedNoteOffAlreadyNoteOff = isRequestedPitchAlreadyAtZeroVelocity;
var shouldNoteOffBeNoteOn = isSimulatedNoteOff && isRequestedNoteOffAlreadyNoteOff;
if (shouldNoteOffBeNoteOn)
{
var averagePreviousNoteVelocities = (byte)(lastNoteOnVelocities.Average());
Console.WriteLine($"<!!! CAUGHT !!!> On (simulated) {counter1++}: {pitch} at {String.Format("{0:0%}", averagePreviousNoteVelocities / 127.0)}");
noteVelocityMap[pitch] = averagePreviousNoteVelocities;
engine.Interpreter.Input(new NotePress()
{
Pitch = pitch,
Velocity = averagePreviousNoteVelocities
});
}
else
{
/** The Yamaha P-45 sends Note Off messages as Note On
* messages with zero velocity. */
var isNoteOnActuallyNoteOff = velocity == 0;
if (isNoteOnActuallyNoteOff)
{
Console.WriteLine($"Off (simulated) {counter1++}: {pitch} at {String.Format("{0:0%}", velocity / 127.0)} <---> (Last) {String.Format("{0:0%}", (byte)noteVelocityMap[pitch] / 127.0)}");
noteVelocityMap[pitch] = 0;
engine.Interpreter.Input(new NoteRelease()
{
Pitch = pitch
});
}
else
{
lastNoteOnVelocities.Enqueue(velocity);
if (lastNoteOnVelocities.Count > 3)
{
lastNoteOnVelocities.Dequeue();
}
noteVelocityMap[pitch] = velocity;
Console.WriteLine($"On {counter1++}: {pitch} at {String.Format("{0:0%}", velocity / 127.0)}");
engine.Interpreter.Input(new NotePress()
{
Pitch = pitch,
Velocity = velocity
});
}
}
}
break;
case MidiEvent.CC:
{
var pedalKind = e.Data[1];
var position = (byte)(127 - e.Data[2]);
// Console.WriteLine($"Pedal {counter1++}: {String.Format("{0:0%}", position / 127.0)}");
engine.Interpreter.Input(new PedalChange()
{
Pedal = PedalKind.Sustain,
Position = position
});
}
break;
}
};
}
engine.Interpreter.Output += (IPianoEvent e) =>
{
foreach (var output in engine.MidiOutputs)
{
switch (e)
{
case PedalChange pedal:
output.Send(new byte[]
{
MidiEvent.CC,
pedal.Pedal switch
{
PedalKind.UnaCorda => 67,
PedalKind.Sostenuto => 66,
PedalKind.Sustain => 64,
_ => 64
},
(byte)(pedal.Position)
}, 0, 3, 0);
break;
public void SetUp()
{
_gameScorer = new GameScorer(new Player("Player 1"), new Player("Player 2"));
_scoreBuilder = new ScoreBuilder(_gameScorer);
}
