public Round()
{
Result = RoundResult.Unknown;
for (int i = 0; i < 4; i++)
{
Yaku[i] = new List<Yaku>();
Hands[i] = new List<Hand>();
Shanten[i] = new List<int>();
WinWaiting[i] = new List<int>();
Pay[i] = 0;
HanCount[i] = 0;
FuCount[i] = 0;
Cost[i] = 0;
Riichi[i] = -1;
OpenedSets[i] = 0;
Naki[i] = 0;
StepCount[i] = 0;
Wind[i] = -1;
Tempai[i] = false;
Dealer[i] = false;
Loser[i] = false;
Winner[i] = false;
BalanceBefore[i] = 0;
BalanceAfter[i] = 0;
}
}
public void GameClosedByShouldReturnSecondPlayerWhenTheSecondPlayerIsGameCloser()
{
var firstRoundPlayerInfo = new RoundPlayerInfo(new Mock <IPlayer>().Object);
var secondRoundPlayerInfo = new RoundPlayerInfo(new Mock <IPlayer>().Object)
{
GameCloser = true
};
var roundResult = new RoundResult(firstRoundPlayerInfo, secondRoundPlayerInfo);
Assert.Equal(PlayerPosition.SecondPlayer, roundResult.GameClosedBy);
}
public Task GameRoundEnded(RoundResultDto data)
{
var settings = new EumelRoundSettings(data.GameRound.StartingPlayer, data.GameRound.TricksToPlay);
var res = new RoundResult(data.PlayerResults.Select(
player => new PlayerRoundResult(player.Guesses, player.TricksWon, player.Score)
).ToList());
var e = new RoundEnded(data.GameId, settings, res);
_gameSeriesEventCallback(e);
return(Task.CompletedTask);
}
private static void PrintRoundResult(RoundResult r)
{
Console.WriteLine("Attacker: " + r.Attacker);
Console.WriteLine("Defender: " + r.Defender);
PrintSurpriseStrikeResult(r.AttackerSurpriseResult, "Attacker");
PrintSurpriseStrikeResult(r.DefenderSurpriseResult, "Defender");
Console.WriteLine("Attacker Hits: " + r.AttackerResult);
Console.WriteLine("Defender Hits: " + r.DefenderResult);
}
public void NoTricksPlayerShouldReturnNoOnePlayerWhenBothPlayerHaveTricks()
{
var firstRoundPlayerInfo = new RoundPlayerInfo(new Mock <IPlayer>().Object);
var secondRoundPlayerInfo = new RoundPlayerInfo(new Mock <IPlayer>().Object);
var roundResult = new RoundResult(firstRoundPlayerInfo, secondRoundPlayerInfo);
firstRoundPlayerInfo.TrickCards.Add(Card.GetCard(CardSuit.Club, CardType.Ace));
secondRoundPlayerInfo.TrickCards.Add(Card.GetCard(CardSuit.Club, CardType.Ten));
Assert.Equal(PlayerPosition.NoOne, roundResult.NoTricksPlayer);
}
public RoundMemo(List <Card> dealer,
List <Card> player,
int bet,
int won,
RoundResult res)
{
DealerHand = dealer;
PlayerHand = player;
PlayerBet = bet;
PlayerReturn = won;
Result = res;
}
public override void AfterAttack(IPlayer player, ISpell spell, RoundResult rr)
{
if (GimmickResource >= 65)
{
// TODO: Set this variable
AllowFrenziedWrathAbilities = true;
}
if (player.Settings.PrimaryWeaponProc == WeaponProc.BloodDrinkers && spell.SpellType == SpellType.Dot)
{
GimmickResource = +3;
}
}
public void GiveWinnerTheirCards(RoundResult roundResult, ref List <Card> myCards, ref List <Card> playerCards, ref List <Card> deck)
{
if (roundResult == RoundResult.RyanWins)
{
myCards.AddRange(deck);
}
else
{
playerCards.AddRange(deck);
}
deck.Clear();
}
public QBClient(int clientID, int laneID, int team, string playeNname, string playerPercentage)
{
ClientId = clientID;
Lane = laneID;
Team = team;
PlayerName = playeNname;
PlayerPercentage = playerPercentage;
for (int i = 0; i < Results.Length; i++)
{
Results[i] = new RoundResult();
}
}
public override void AfterAttack(IPlayer player, ISpell spell, RoundResult rr)
{
if (player.Settings.PrimaryWeaponProc == WeaponProc.UnstableElectronCore && GimmickResource > 50 && (spell.ElementalType == "Fire" || spell.ElementalType == "Lightning"))
{
player.AddBonusAttack(rr, new UnstableElectronCore());
}
if (player.Settings.PrimaryWeaponProc == WeaponProc.CryoChargedConduit && spell.ElementalType == "Cold")
{
GimmickResource -= 15;
//TODO: and cause any targets hit to become frostbitten for 6 seconds. Critically hitting a frostbitten enemy with an Elemental attack deals an additional (3.45*Combat Power) magical damage.
//What does it even mean?
}
}
private void UpdateScore(RoundResult result)
{
if (result == RoundResult.AWins)
{
PlayerScore++;
displayer.UpdatePlayerScore(PlayerScore);
}
else if (result == RoundResult.BWins)
{
CPUScore++;
displayer.UpdateCPUScore(CPUScore);
}
}
void EndRoundNotification(RoundResult roundResult)
{
//Increment the appropirate counter to show who is winning
if (roundResult.Victor == BattleVictor.Party1 ||
roundResult.Victor == BattleVictor.PVE)
{
_party1VictoryCount++;
}
else if (roundResult.Victor == BattleVictor.Party2 ||
roundResult.Victor == BattleVictor.Boss)
{
_party2VictoryCount++;
}
else
{
//F**k you
}
//We've updated the victory count for these f***s. Now hide the battle panel.
// Then, depending on the number of current victories, either show a TRIUMPH! screen of some sort,
// or trigger a new combat sequence.
BattlePanel.SetActive(false);
if (_party1VictoryCount >= _victoriesNeededToWin)
{
if (_bossFight)
{
StartPVEVictory();
}
else
{
StartParty1Victory();
}
}
else if (_party2VictoryCount >= _victoriesNeededToWin)
{
if (_bossFight)
{
StartBossVictory();
}
else
{
StartParty2Victory();
}
}
else
{
//Nobody won yet. Need to fight another round.
StartLoadingScreen();
}
}
void ShowRoundVictoryPanel(RoundResult roundResult)
{
_roundResult = roundResult;
_buttonNamePanel.Hide();
PlayVictorySound();
_resolutionPanel.SetVictor(roundResult);
_resolutionPanel.Show();
StartCoroutine(UnthreadedDelay(
RoundVictoryTimeSeconds,
EndRoundVictoryScreen
));
}
public void IdenticalMovesShouldResultInADraw()
{
// arrange
var paperDraw = new RoundResult(Move.Paper, Move.Paper);
var rockDraw = new RoundResult(Move.Rock, Move.Rock);
var scissorsDraw = new RoundResult(Move.Scissors, Move.Scissors);
// act
// assert
Assert.True(Result.Draw == paperDraw.Result);
Assert.True(Result.Draw == rockDraw.Result);
Assert.True(Result.Draw == scissorsDraw.Result);
}
public MatchResult(MatchResult source)
{
warriorsCount = source.warriorsCount;
rounds = source.rounds;
formula = source.formula;
results = new RoundResult[warriorsCount, rounds];
for (int w = 0; w < warriorsCount; w++)
{
for (int r = 0; r < rounds; r++)
{
results[w, r] = source.results[w, r];
}
}
}
public void SetPlayerChoice(Shape playerShape)
{
if (!RoundInActivePhase)
{
return;
}
RoundInActivePhase = false;
Shape opponentShape = gameManager.GetOpponentShape(playerShape);
RoundResult result = gameManager.ProceedRound(playerShape, opponentShape);
StartCoroutine(RoundRoutine(playerShape, opponentShape, result));
}
public Round(Player p1, Player p2, int roundNumber, Random rng, ILogger logger)
{
this._logger = logger;
this.p1 = p1;
this.p2 = p2;
this.p1Choice = (Choice)rng.Next(3);
this.p2Choice = (Choice)rng.Next(3);
this.roundNumber = roundNumber;
this.result = Round.DetermineWinner(p1Choice, p2Choice);
_logger.LogTrace($"Round result: {this.result}");
// Save the win or loss count for each player.
Round.AdjustPlayerWinLossCount(p1, p2, this.result);
}
private void WeaponAfterAttack(RoundResult rr, ISpell spell)
{
var attack = rr.Attacks.FirstOrDefault(a => a.Spell == spell);
if (attack == null || !attack.IsHit)
{
return;
}
var weapon = GetWeaponFromSpell(attack.Spell);
weapon?.AfterAttack(this, attack.Spell, rr);
weapon?.WeaponAffixes(this, attack.Spell, rr);
}
public MatchResult RunMatch(IBot player1, IBot player2)
{
var roundResults = new List <RoundResult>();
var roundRunner = new RoundRunner();
RoundResult previoResult = new RoundResult();
for (int i = 0; i < 1000; i++)
{
previoResult = roundRunner.RunRound(player1, player2, previoResult);
roundResults.Add(previoResult);
}
return(GetMatchResultFromRoundResults(player1, player2, roundResults));
}
public RoundResult InverseResult(RoundResult result)
{
switch (result)
{
case RoundResult.Win:
result = RoundResult.Lose;
break;
case RoundResult.Lose:
result = RoundResult.Win;
break;
}
return(result);
}
public void AdjustForRoundResultOfHand(RoundResult roundResult, double betAmount, ref double walletAmount, List <Card> dealerCards, List <Card> playerCards, Hand dealerHand, Hand playerHand)
{
switch (roundResult)
{
case RoundResult.PlayerBlackJack:
Message.WonWithABlackJack(2.5 * betAmount);
walletAmount += 2.5 * betAmount;
break;
case RoundResult.DealerBlackJack:
Message.LostToABlackJack(dealerCards[0].ToString());
break;
case RoundResult.Won:
Message.WonHand(playerHand.Points(playerCards), dealerHand.Points(dealerCards), (2 * betAmount));
walletAmount += 2 * betAmount;
break;
case RoundResult.Lost:
Message.LostHand(playerHand.Points(playerCards), dealerHand.Points(dealerCards));
break;
case RoundResult.Tied:
Message.TiedHand(playerHand.Points(playerCards), betAmount);
walletAmount += betAmount;
break;
case RoundResult.Surrendered:
Message.ChoseToSurrender(.5 * betAmount);
walletAmount += .5 * betAmount;
break;
case RoundResult.Busted:
Message.YouBusted(playerHand.Points(playerCards));
break;
case RoundResult.DealerBusts:
Message.DealerBusted(dealerHand.Points(dealerCards), (2 * betAmount));
walletAmount += 2 * betAmount;
break;
case RoundResult.Unknown:
break;
default:
break;
}
}
internal Decision GetDecision(BaseBot player, RoundResult previousResult, IMetrics metrics)
{
var stopwatch = System.Diagnostics.Stopwatch.StartNew();
var d = player.GetDecision(previousResult.ToPlayerSpecific(player));
stopwatch.Stop();
var metric = new Dictionary <string, double> {
{ "DecisionTime", stopwatch.Elapsed.TotalMilliseconds }
};
var properties = new Dictionary <string, string> {
{ "Bot", player.Name }
};
metrics.TrackEventDuration("BotDesicionTime", properties, metric);
return(d);
}
public override void PreAttack(IPlayer player, RoundResult rr)
{
if (player.Settings.PrimaryWeaponProc == WeaponProc.BladedGauntlets && _bladedStartBonus == 1)
{
GimmickResource = +15;
_bladedStartBonus = 2;
}
if (player.Settings.PrimaryWeaponProc == WeaponProc.BladedGauntlets)
{
GimmickResource = +2;
}
if (player.Settings.PrimaryWeaponProc == WeaponProc.TreshingClaws && AllowFrenziedWrathAbilities)
{
player.AddBonusAttack(rr, new TreshingClaws(player));
}
}
private void EndRound(RoundResult rr, ISpell spell)
{
var attack = rr.Attacks.FirstOrDefault(a => a.Spell == spell);
if (attack != null && attack.IsHit)
{
var weapon = GetWeaponFromSpell(attack.Spell);
if (attack.IsCrit)
{
// TODO: Make sure this can never happen more than 1/s
// Energy on crit 1s IDC
weapon?.EnergyOnCrit(this);
}
}
}
public void Test1()
{
// arrange
var roundResult = new RoundResult(Move.Paper, Move.Paper);
Assert.True(RoundResult, RoundResult.win)
Console.WriteLine(roundResult);
// act
// assert
// throw new NotImplementedException();
}
public override void PreAttack(IPlayer player, RoundResult rr)
{
// Only on first activation
if (!_init)
{
_init = true;
// 0.32CP damage on matching chambers for 3s
_jackpot = player.GetPassive(nameof(Jackpot));
// If you haven't used a Pistol Ability in the last 4s your right chamber is set to match your left chamber
_fixedGame = player.GetPassive(nameof(FixedGame));
// If no matching chambers gain Double White, BaseDamage of Kill Blind increased to 3,47CP
_focusedFire = player.GetPassive(nameof(FocusedFire));
// Whenever your Pistol Energy reaches 15 you automatically gain Double White set if you do not already have a set
_fullyLoaded = player.GetPassive(nameof(FullyLoaded));
// 0.06CP-0.335CP on matching chamber hit
_winStreak = player.GetPassive(nameof(WinStreak));
// If matching set of chambers Pistol attacks TAoE 0,09CP BaseDamage
_flechetteRounds = player.GetPassive(nameof(FlechetteRounds));
// Unload: 33% Chance to not spin chambers if matching set
_holdout = player.GetPassive(nameof(Holdout));
_annihilators = player.Settings.PrimaryWeaponProc == WeaponProc.Cb3Annihilators;
_harmonisers = player.Settings.PrimaryWeaponProc == WeaponProc.SovTechHarmonisers;
}
var timeSinceLastPistolSpell = player.CurrentTimeSec - LastPistolSpellTimeStamp;
if (_fullyLoaded != null && Energy == 15 && LeftChamber != RightChamber)
{
RightChamber = Chamber.White;
LeftChamber = Chamber.White;
ChamberLockTimeStamp = player.CurrentTimeSec;
}
if (_fixedGame != null && timeSinceLastPistolSpell >= 4 && LeftChamber != RightChamber)
{
RightChamber = LeftChamber;
ChamberLockTimeStamp = player.CurrentTimeSec;
}
}
private void ChangeCountStatus(GamerInfo gamerInfo, RoundResult status)
{
switch (status)
{
case RoundResult.Draw:
gamerInfo.CountDraws++;
break;
case RoundResult.Lose:
gamerInfo.CountLoses++;
break;
case RoundResult.Win:
gamerInfo.CountWins++;
break;
}
}
public RoundSummary(int nRonda, PlayerAction acao, int posicaoFinalRonda, int inimigosVencidos, int fugas, int itensEncontrados,
bool chave, int ouro, double vidaFinal, int ataqueFinal, int sorteFinal, int pocoesFinal, RoundResult resultadoAcao)
{
NrRonda = nRonda;
DecisaoTomada = acao;
PosicaoFinalRonda = posicaoFinalRonda;
TotalAcumuladoInimigosVencidos = inimigosVencidos;
TotalAcumuladoFugas = fugas;
TotalAcumuladoItensEncontrado = itensEncontrados;
TerChave = chave;
MoedasDeOuro = ouro;
PontosVidaFinais = vidaFinal;
PontosSorteFinais = sorteFinal;
PontosAtaqueFinais = ataqueFinal;
PocoesVidaFinais = pocoesFinal;
ResultadoAcao = resultadoAcao; //Apenas para ver se as ações são válidas
}
private bool ContinueRound(RoundResult rr, ISpell prevSpell)
{
// Order when continuing a round
var actions = rr.Attacks.Count;
Item.PreAttack(rr);
WeaponPreAttack(rr);
var spell = ExecuteAction(rr, prevSpell);
ExecuteBuff(rr, spell);
Item.AfterAttack(rr, spell);
WeaponAfterAttack(rr, spell);
PassiveBonusSpells(rr, spell);
EndRound(rr, spell);
// Did any change occur?
return(actions != rr.Attacks.Count);
}
private static Dictionary <int, RoundResult> GetSimpleResult(ListHeaderModel model)
{
Dictionary <int, RoundResult> result = new Dictionary <int, RoundResult>();
foreach (var res in model.Results)
{
var rr = new RoundResult
{
ClimberId = res.Climber.SecretaryId.Value,
Pos = res.Position ?? 0,
Pts = res.Points ?? 0.0,
RouteNum = res.PreQf ? 0 : ((res.Position == null) ? int.MaxValue : 1),
ResText = res.ResText ?? String.Empty
};
result.Add(rr.ClimberId, rr);
}
return(result);
}
public override void AfterAttack(IPlayer player, ISpell spell, RoundResult rr)
{
var roll = Rnd.Next(1, 6);
if (player.Settings.PrimaryWeaponProc == WeaponProc.IfritanDespoiler)
{
if (spell.GetType() == typeof(DragonBreath))
{
_ifritanDespoilerCounter += 2;
}
if (spell.GetType() == typeof(DepletedUranium))
{
_ifritanDespoilerCounter++;
}
if (_ifritanDespoilerCounter >= 12)
{
player.AddBonusAttack(rr, new IfritanDespoiler(player, ""));
_ifritanDespoilerCounter = 0;
}
}
if (player.Settings.PrimaryWeaponProc == WeaponProc.Spesc221 && GimmickResource < _shellstamp && roll == 5)
{
player.AddBonusAttack(rr, new SpesC221());
}
// Not all spells should procc gimmick
if (spell.GetType() == typeof(Reload) || spell.GetType() == typeof(ShellSalvage))
{
return;
}
if (Rnd.Next(1, 3) == 1)
{
// TODO: Check & FIX DOT duration/stacks and assume perfect play by default
// in weapon-model so APL does not have to worry about it at all.
player.AddBonusAttack(rr, new DragonBreath());
}
else
{
player.AddBonusAttack(rr, new DepletedUranium());
}
}
async void paxos_RoundComplete(object sender, RoundResult e)
{
long sequenceNumber;
if (long.TryParse(e.RoundID, out sequenceNumber))
{
SequencedTransactionID.AutoIncrementOn(sequenceNumber);
Sequencing.TrySet(sequenceNumber, e.Result);
pendingTransactions++;
var committed = await TransactionResults.Get(e.Result);
pendingTransactions--;
if (committed)
{
OnTransactionCommited(sequenceNumber, e.Result);
}
else
{
CompletedTransactionID.AutoIncrementOn(sequenceNumber);
}
}
else
{
if (e.Result == "COMMIT")
{
TransactionResults.TrySet(e.RoundID, true);
}
else
{
TransactionUpdates.Dispose(e.RoundID);
TransactionResults.TrySet(e.RoundID, false);
}
if (pendingTransactions == 0)
{
//check we're not behind on sequence numbers
SendMessage("SequenceNumber", SequencedTransactionID.Current().ToString());
}
}
}
void nooneWonRound()
{
//Debug.Log("Round is draw");
currentRoundResult = RoundResult.draw;
resultText.GetComponent<TextMesh>().text = "Result: Round is draw";
}
void player2WonRound()
{
//Debug.Log("Player 2 won");
currentRoundResult = RoundResult.player2Won;
player2Script.roundsWon++;
player2Script.OverallScore++;
determineBonusScore(player2Script);
resultText.GetComponent<TextMesh>().text = "Result: Player 2 won. +1 Score";
}
public void ThenTheResultForPlayerXIsY(int player, RoundResult expectedResult)
{
var actualResult = round.GetResults()[player];
Assert.That(actualResult, Is.EqualTo(expectedResult));
}
