public void AdjustMomentum(BeatlineNoteJudgement judgement, int player)
{
if (judgement == BeatlineNoteJudgement.Miss)
{
MultiplyMomentum(0.8, player);
}
else if (judgement == BeatlineNoteJudgement.Fail)
{
MultiplyMomentum(0.7, player);
}
else
{
//Using Players[player] for Sync mode too doesn't matter, since all players will have
//the same difficulty.
var amount = (long)
(MomentumJudgementMultiplier(judgement) *
MomentumIncreaseByDifficulty(Players[player].PlayerOptions.PlayDifficulty));
//Make all players share the same momentum in SYNC modes.
if (_gameType == GameType.SYNC_PRO || _gameType == GameType.SYNC_PLUS)
{
SetMomentumSync(Players[0].Momentum + amount);
}
else
{
Players[player].Momentum += amount;
}
}
}
private void ApplyJudgement(BeatlineNoteJudgement judgement, int player, int multiplier)
{
_noteJudgementSet.AwardJudgement(judgement, player, multiplier, _noteBarSet.NumberCompleted(player) + _noteBarSet.NumberReverse(player));
_levelbarSet.AdjustMomentum(judgement, player);
//Keep scoring sane by adding a delay to the awarding of Groove Momentum.
//Otherwise, the last player to hit each phrase has an advantage.
if (!Core.Cookies["CurrentGameType"].Equals(GameType.COOPERATIVE))
{
return;
}
var thread = new Thread(AdjustGrooveMomentum);
double mx = _noteBarSet.NumberCompleted(player) + _noteBarSet.NumberReverse(player);
//Ideal streaks provide bonus groove momentum (up to 2x the normal amount)
if (judgement == BeatlineNoteJudgement.Ideal)
{
var mx2 = Convert.ToDouble((9 + Math.Max(1, Core.Players[player].Streak)));
mx2 = Math.Min(2.0, mx2 / 10);
mx *= mx2;
}
thread.Start(new GMAdjustment {
Judgement = judgement, Multiplier = mx
});
}
public void RegisterHit(int player, BeatlineNoteJudgement judgement)
{
if ((player < 0) || (player > 3))
{
return;
}
_lastJudgements[player] = judgement;
switch (GameType)
{
case GameType.SYNC_PRO:
case GameType.SYNC_PLUS:
if (!AllHitsReceived())
{
return;
}
//For Sync Pro, multiply the judgement given (for scoring purposes). For Sync Plus, the number of arrows means that
//the judgement should *not* be multiplied.
var mx = GameType == GameType.SYNC_PRO ? PlayerCount() : 1;
SendResponse(new AggregatorResponse
{
Judgement = GetWorstJudgement(), Multiplier = mx, Player = (AggregatorPlayerID)0
});
ResetReceivedHits();
break;
default:
SendResponse(new AggregatorResponse {
Judgement = judgement, Multiplier = 1, Player = (AggregatorPlayerID)player
});
break;
}
}
private double MomentumJudgementMultiplier(BeatlineNoteJudgement judgement)
{
switch (judgement)
{
case BeatlineNoteJudgement.Ideal:
return(1.0);
case BeatlineNoteJudgement.Cool:
return(2.0 / 3);
case BeatlineNoteJudgement.OK:
return(1.0 / 3);
}
return(0.0);
}
private void RecordJudgement(int player, BeatlineNoteJudgement judgement)
{
Players[player].Judgements[(int)judgement]++;
if (!SyncGameType)
{
return;
}
for (int x = 1; x < 4; x++)
{
if (Players[x].Playing)
{
Players[x].Judgements[(int)judgement] = Players[0].Judgements[(int)judgement];
Players[x].Streak = Players[0].Streak;
}
}
}
public BeatlineNoteJudgement DetermineJudgement(double phraseNumber, bool completed)
{
_pulseFrontOpacity = 255;
var nearest = NearestBeatlineNote(phraseNumber);
double offset = (nearest == null) ? 9999 : CalculateHitOffset(nearest, phraseNumber);
offset = Math.Abs(offset);
if (offset > HIT_IGNORE_CUTOFF)
{
//Note that the COUNT judgement is essentially an 'ignored' judgement.
return(BeatlineNoteJudgement.Count);
}
BeatlineNoteJudgement result = GetJudgementResult(offset, completed);
//Mark the beatlinenote as hit (it will be displayed differently and hold position)
if (nearest != null)
{
MarkNoteAsHit(nearest, phraseNumber);
}
return(result);
}
public void AwardJudgement(BeatlineNoteJudgement judgement, int player, int givenMultiplier, int numCompleted)
{
double lifeAdjust = 0;
long scoreAdjust = 0;
switch (judgement)
{
case BeatlineNoteJudgement.Ideal:
Players[player].Streak++;
double multiplier = Convert.ToDouble((9 + Math.Max(1, Players[player].Streak)));
multiplier /= 10;
multiplier = Math.Min(2.0, multiplier);
scoreAdjust = (long)Math.Round(1000 * (numCompleted) * multiplier);
lifeAdjust = (1 * numCompleted);
break;
case BeatlineNoteJudgement.Cool:
scoreAdjust = 750 * numCompleted;
lifeAdjust = (0.5 * numCompleted);
Players[player].Streak = 0;
break;
case BeatlineNoteJudgement.OK:
scoreAdjust = 500 * numCompleted;
Players[player].Streak = 0;
break;
case BeatlineNoteJudgement.Bad:
scoreAdjust = 250 * numCompleted;
Players[player].Streak = 0;
lifeAdjust = -1 * numCompleted;
break;
case BeatlineNoteJudgement.Miss:
Players[player].Streak = 0;
lifeAdjust = Players[player].MissedBeat();
break;
case BeatlineNoteJudgement.Fail:
Players[player].Streak = 0;
lifeAdjust = Players[player].FailedBeat();
break;
case BeatlineNoteJudgement.Count:
//Ignore judgement
break;
}
RecordJudgement(player, judgement);
if (Players[player].CPU)
{
scoreAdjust *= NumHumanPlayers();
}
scoreAdjust *= givenMultiplier;
if (_gameType == GameType.COOPERATIVE)
{
scoreAdjust = (long)Math.Ceiling(scoreAdjust * (Player.GrooveMomentum));
}
if (_gameType == GameType.SYNC_PLUS && lifeAdjust > 0)
{
lifeAdjust /= (from e in Players where e.Playing select e).Count();
}
if (_scoreSet != null)
{
_scoreSet.AdjustScore(scoreAdjust, player);
}
if (_lifeBarSet != null)
{
_lifeBarSet.AdjustLife(lifeAdjust, player);
}
var newDj = new DisplayedJudgement
{
DisplayUntil = _phraseNumber + 0.5,
Size = _metrics["Judgement.Size", 0],
Player = player,
Tier = (int)judgement,
};
newDj.Position = (_metrics["Judgement", player]);
if (SyncGameType)
{
newDj.Position = _metrics["SyncJudgement", player];
newDj.Size = _metrics["SyncJudgement.Size", 0].Clone();
newDj.Height *= (from e in Players where e.Playing select e).Count();
newDj.TextureSet = (from e in Players where e.Playing select e).Count();
}
_displayedJudgements[player] = newDj;
}
public virtual void ApplyJudgement(BeatlineNoteJudgement judgement, int player, double multiplier)
{
}
