private static ThrowResult GetPlayerThrow()
{
ThrowResult output = (ThrowResult)(-1);
bool valid = false;
while (!valid)
{
Console.WriteLine("Choose throw: ");
Console.WriteLine("1) Rock");
Console.WriteLine("2) Paper");
Console.WriteLine("3) Scissors");
Console.Write("Input choice: ");
if (InputIsValid(Console.ReadLine(), 1, 3, out int throwChoice))
{
output = (ThrowResult)throwChoice - 1;
if (!EnumHelper.EnumValueIsValid(output))
{
throw new InvalidOperationException("Something is not quite right, You're throw wasn't found in the ThrowResult enum!");
}
valid = true;
}
}
Console.WriteLine();
Console.Clear();
return(output);
}
private static void PlayRound(RockPaperScissors rockPaperScissors, ref int playerScore, ref int computerScore)
{
ThrowResult computerThrow = rockPaperScissors.GetComputerThrow();
ThrowResult playerThrow = GetPlayerThrow();
Winner winner = rockPaperScissors.DetermineWinner(playerThrow, computerThrow);
Console.WriteLine($"You threw: {Enum.GetName(playerThrow)}");
Console.WriteLine($"The computer threw: {Enum.GetName(computerThrow)}");
if (winner == Winner.Player1)
{
Console.WriteLine("You win this round!");
playerScore++;
}
else if (winner == Winner.Player2)
{
Console.WriteLine("The computer won this round!");
computerScore++;
}
else
{
Console.WriteLine("It's a tie!");
}
}
public void PlayMatch()
{
var leg = new SinglePlayerLeg(126)
// Turn #1
.WithAdditionalThrow(ThrowResult.Triple(20))
.WithAdditionalThrow(ThrowResult.Double(20))
.WithAdditionalThrow(ThrowResult.Single(20))
// Score = 6
// Turn #2
.WithAdditionalThrow(ThrowResult.Outside)
.WithAdditionalThrow(ThrowResult.Outside)
.WithAdditionalThrow(ThrowResult.Outside)
// Turn #3. Bust! Not double!
.WithAdditionalThrow(ThrowResult.Triple(2))
// Turn #4. Bust! Too many!
.WithAdditionalThrow(ThrowResult.InnerBull)
// Turn #5. Bust! Can't leave 1.
.WithAdditionalThrow(ThrowResult.Single(5))
// Turn #6. Finished
.WithAdditionalThrow(ThrowResult.Double(3));
Assert.AreEqual(6, leg.Turns.Count);
Assert.AreEqual(0, leg.Score);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
if (reader.TokenType != JsonToken.String)
{
throw new JsonSerializationException("ThrowResult should be string in json");
}
return(ThrowResult.Parse(reader.Value.ToString()));
}
private async Task SendCurrentOppoThrow(RoomActor roomActor, ThrowResult throwResult)
{
foreach (var otherAU in roomActor.Room.RoomUsers
.Where(ru => ru != roomActor).Select(ru => ru.ActiveUser))
{
await _masterHub.SendOrderedAsync(otherAU, "CurrentOppoThrow", throwResult);
}
}
public void NotFinish_IfBothPlayersHasNonZeroScore()
{
var leg = new Leg("id", 20);
leg.AddThrow(ThrowResult.Single(10));
Assert.IsFalse(leg.Finished);
Assert.AreEqual(-1, leg.WinnerIndex);
}
public void StartNewLeg_AfterLegFinished()
{
var match = new Match("1", new[] { "p1", "p2" }, 20, 2);
match.AddThrow(ThrowResult.Double(10));
match.AddThrow(ThrowResult.Double(10));
Assert.AreEqual(2, match.Legs.Count);
Assert.IsTrue(match.CurrentLeg.Finished);
}
public void Finish_IfOnlyOneHasNonZeroScore()
{
var leg = new Leg("id", 20);
leg.AddThrow(ThrowResult.Triple(20)); //0 bust!
leg.AddThrow(ThrowResult.Double(10)); //1 finished
Assert.IsTrue(leg.Finished);
Assert.AreEqual(1, leg.WinnerIndex);
}
private void GameView_OnThrowBegin(int xPos)
{
ThrowResult result = MyGame.GetThrowResult(xPos);
GameSession.Scores += result.HitResult ? 1 : -1;
ThrowResultDT resDT = new ThrowResultDT(result.Row, result.Column, result.HitResult);
int yPos = result.Row == -1 ? 0 : (result.Row + 1) * FieldSettings.PictureHeight;
this.GameView.AnimateBall(resDT, yPos);
}
public void ForceThrow(ThrowResult throwResult)
{
IsPlayable = false; //redundant i think
var card = HandCards.First(c => c.Front.Index == throwResult.ThrownCard);
var throwSeq = DOTween.Sequence();
var targetPoz = PlaceCard(card, throwSeq);
ThrowBase(throwResult, animSeq: throwSeq, meetPoint: targetPoz);
}
public void BeSerializable()
{
var turn = new Turn(301)
.WithAdditionalThrow(ThrowResult.Outside)
.WithAdditionalThrow(ThrowResult.Single(1))
.WithAdditionalThrow(ThrowResult.Double(2));
var res = JsonConvert.SerializeObject(turn, new ThrowJsonConverter());
Assert.AreEqual(@"{""Throws"":[""0"",""1"",""D2""],""ScoreBefore"":301,""ScoreAfter"":296,""Finished"":true,""Bust"":false}", res, res);
var deserialized = JsonConvert.DeserializeObject <Turn>(res, new ThrowJsonConverter());
Assert.AreEqual(turn, deserialized);
}
public async UniTask Throw(ThrowResult throwResult)
{
var randCard = HandCards.GetRandom();
await randCard.AddFront(throwResult.ThrownCard);
//check if call is awaitable and wait for it from the controller itself
var throwSeq = DOTween.Sequence();
var targetPoz = PlaceCard(randCard, throwSeq);
ThrowBase(throwResult, throwSeq, targetPoz);
}
public void ChangePlayer_AfterTurnFinished()
{
var match = new Match("1", new[] { "p1", "p2" }, 301, 2);
match.AddThrow(ThrowResult.Single(1));
match.AddThrow(ThrowResult.Single(2));
match.AddThrow(ThrowResult.Single(3));
// Player 1 turn is finished
match.AddThrow(ThrowResult.Single(4));
Assert.AreEqual(1, match.CurrentLeg.GetPlayerTurns(0).Count);
Assert.AreEqual(1, match.CurrentLeg.GetPlayerTurns(1).Count);
}
protected void ConvertAndSaveThrow(DetectedThrow detectedThrow,
ThrowResult throwResult = ThrowResult.Ordinary)
{
var convertedThrow = new Throw(Game.PlayerOnThrow,
detectedThrow.Sector,
detectedThrow.Type,
throwResult,
(int)Game.PlayerOnThrow.GameData.ThrowNumber,
detectedThrow.TotalPoints,
detectedThrow.Poi,
detectedThrow.ProjectionResolution);
Game.Throws.Push(convertedThrow);
Game.PlayerOnThrow.GameData.HandThrows.Add(convertedThrow);
}
public Throw(Player player, Domain.Game game, int sector, ThrowType type, ThrowResult result,
int number, int points, PointF poi, int projectionResolution, int id = -1)
{
Id = id;
Player = player;
Game = game;
Sector = sector;
Type = type;
Result = result;
Number = number;
Points = points;
Poi = poi;
ProjectionResolution = projectionResolution;
TimeStamp = DateTime.Now;
}
protected Throw ConvertAndSaveThrow(DetectedThrow thrw, ThrowResult throwResult)
{
var dbThrow = new Throw(PlayerOnThrow,
Game,
thrw.Sector,
thrw.Type,
throwResult,
PlayerOnThrow.ThrowNumber,
thrw.TotalPoints,
thrw.Poi,
thrw.ProjectionResolution);
dbService.ThrowSaveNew(dbThrow);
return(dbThrow);
}
protected void ThrowBase(ThrowResult result, Sequence animSeq = null,
Vector2?meetPoint = null)
{
AudioManager.I.PlayIfSilent(throwClip);
animSeq ??= DOTween.Sequence();
var card = HandCards.First(c => c.Front != null && c.Front.Index == result.ThrownCard);
Ground.I.Throw(card, result.EatenCardsIds, animSeq, meetPoint);
var count = result.EatenCardsIds?.Count ?? 0;
HandCards.Remove(card);
OrganizeHand();
CoreGameplay.I.NextTurn();
}
public void BeSerializable()
{
var match = new Match("1", new[] { "p1", "p2" }, 20, 2);
match.AddThrow(ThrowResult.Double(10));
match.AddThrow(ThrowResult.Double(10));
var text = JsonConvert.SerializeObject(match, Formatting.Indented, new ThrowJsonConverter());
Console.WriteLine(text);
var deserializedMatch = JsonConvert.DeserializeObject <Match>(text, new ThrowJsonConverter());
var text2 = JsonConvert.SerializeObject(deserializedMatch, Formatting.Indented, new ThrowJsonConverter());
Console.WriteLine(text2);
Assert.AreEqual(text, text2);
}
public void BeSerializable()
{
var leg = new Leg("1", 20);
leg.AddThrow(ThrowResult.Single(10)); //#1
leg.AddThrow(ThrowResult.Triple(20)); //#1 bust!
leg.AddThrow(ThrowResult.Double(10)); //#2 finished
var text = JsonConvert.SerializeObject(leg, Formatting.Indented, new ThrowJsonConverter());
Console.WriteLine(text);
var deserialized = JsonConvert.DeserializeObject <Leg>(text, new ThrowJsonConverter());
var text2 = JsonConvert.SerializeObject(deserialized, Formatting.Indented, new ThrowJsonConverter());
Console.WriteLine(text2);
Assert.AreEqual(text, text2);
}
private static IEmote GetEmoji(ThrowResult throwResult)
{
if (!EnumHelper.EnumValueIsValid(throwResult))
{
throw new ArgumentException("Argument is invalid.", nameof(throwResult));
}
switch (throwResult)
{
case ThrowResult.Rock:
return(new Emoji("🪨"));
case ThrowResult.Paper:
return(new Emoji("🧻"));
case ThrowResult.Scissors:
return(new Emoji("✂️"));
default:
return(new Emoji("❓"));
}
}
public ThrowResult GetThrowFromString(string stringThrow)
{
ThrowResult playerThrow = ThrowResult.Invalid;
switch (stringThrow)
{
case "rock":
playerThrow = ThrowResult.Rock;
break;
case "paper":
playerThrow = ThrowResult.Paper;
break;
case "scissors":
playerThrow = ThrowResult.Scissors;
break;
default:
playerThrow = ThrowResult.Invalid;
break;
}
return(playerThrow);
}
public void ForcePlay(ThrowResult throwResult)
{
MyPlayer.ForceThrow(throwResult);
}
public Winner DetermineWinner(ThrowResult player1Result, ThrowResult Player2Result)
{
Winner winner = (Winner)(-1);
if (!EnumHelper.EnumValueIsValid(player1Result))
{
throw new ArgumentException("Argument is invalid.", nameof(player1Result));
}
if (!EnumHelper.EnumValueIsValid(Player2Result))
{
throw new ArgumentException("Argument is invalid.", nameof(Player2Result));
}
switch (player1Result)
{
case ThrowResult.Rock:
switch (Player2Result)
{
case ThrowResult.Rock:
winner = Winner.Tie;
break;
case ThrowResult.Paper:
winner = Winner.Player2;
break;
case ThrowResult.Scissors:
winner = Winner.Player1;
break;
default:
break;
}
break;
case ThrowResult.Paper:
switch (Player2Result)
{
case ThrowResult.Rock:
winner = Winner.Player1;
break;
case ThrowResult.Paper:
winner = Winner.Tie;
break;
case ThrowResult.Scissors:
winner = Winner.Player2;
break;
default:
break;
}
break;
case ThrowResult.Scissors:
switch (Player2Result)
{
case ThrowResult.Rock:
winner = Winner.Player2;
break;
case ThrowResult.Paper:
winner = Winner.Player1;
break;
case ThrowResult.Scissors:
winner = Winner.Tie;
break;
default:
break;
}
break;
default:
break;
}
if (!EnumHelper.EnumValueIsValid(winner))
{
throw new InvalidOperationException("Winner value not valid");
}
return(winner);
}
public async static Task RPSProcessor(Cacheable <IUserMessage, ulong> cachedEntity, ISocketMessageChannel channel, SocketReaction reaction)
{
var message = (SocketUserMessage)cachedEntity.Value;
var reactingUser = (SocketUser)reaction.User;
if (reactingUser.IsBot || message == null)
{
return;
}
if (message.Content.StartsWith("Game over: "))
{
if (message.Reactions.ContainsKey(new Emoji("❗")))
{
await message.ModifyAsync(x => x.Content = "Choose Rock, Paper, or Scissors!");
await message.RemoveAllReactionsAsync();
IEmote[] rpsReactions = new IEmote[]
{
new Emoji("🪨"),
new Emoji("🧻"),
new Emoji("✂️"),
new Emoji("❗"),
};
await message.AddReactionsAsync(rpsReactions);
}
}
if (message.Content == "Choose Rock, Paper, or Scissors!")
{
var reactions = message.Reactions;
IEmote usersReaction = null;
foreach (var r in reactions)
{
if (r.Value.ReactionCount > 1)
{
usersReaction = r.Key;
}
}
ThrowResult playerThrow = (ThrowResult)(-1);
if (usersReaction.Name == "🪨")
{
playerThrow = ThrowResult.Rock;
}
else if (usersReaction.Name == "🧻")
{
playerThrow = ThrowResult.Paper;
}
else if (usersReaction.Name == "✂️")
{
playerThrow = ThrowResult.Scissors;
}
else
{
return;
}
ThrowResult computerThrow = EnumHelper.RandomEnumValue <ThrowResult>();
var winner = DetermineWinner(computerThrow, playerThrow);
string outputMessage = "Game over: ";
if (winner == Winner.Bot)
{
outputMessage += $"{ message.Author.Mention } *won* by throwing { GetEmoji(computerThrow) } against { usersReaction.Name}!";
}
else if (winner == Winner.Player)
{
outputMessage += $"{ reactingUser.Mention } *won* by throwing { usersReaction.Name} against { GetEmoji(computerThrow) }!";
}
else
{
outputMessage += $"It's a tie! { GetEmoji(computerThrow)} vs { GetEmoji(playerThrow) }!";
}
await message.ModifyAsync(msg => msg.Content = outputMessage);
}
}
public void Parse(string input, int expectedSector, SectionArea expedtedMultiplier)
{
var t = ThrowResult.Parse(input);
Assert.AreEqual(new ThrowResult(expectedSector, expedtedMultiplier), t);
}
public void ValidateInput(string input, bool expectedIsValid)
{
Assert.AreEqual(expectedIsValid, ThrowResult.IsValid(input));
}
public void MyThrowResult(ThrowResult throwResult)
{
MyPlayer.MyThrowResult(throwResult);
}
public void MyThrowResult(ThrowResult result)
{
ThrowBase(result);
}
public async UniTask CurrentOppoThrow(ThrowResult throwResult)
{
await((IOppo)PlayerInTurn).Throw(throwResult);
}
