public void TestPointsAsOnePair2()
{
var diceSet = new DiceSet(6, 3, 1, 2, 5);
var points = diceSet.GetPointsAsOnePair();
Assert.AreEqual(0, points);
}
public void TestLowerYahtzee()
{
DiceSet set = new DiceSet(new Random());
ScoreCard scoreCard = new ScoreCard();
{
set[0].Number = 1;
set[1].Number = 1;
set[2].Number = 1;
set[3].Number = 1;
set[4].Number = 1;
Assert.IsTrue(scoreCard.SLOT_YAHTZEE.Qualifier(set), "Failed to qualifiy exactly 5");
int expected = 50;
int actual = scoreCard.SLOT_YAHTZEE.ScorePotential(set);
Assert.AreEqual(expected, actual, "Gave wrong score for exact 5");
}
{
set[0].Number = 1;
set[1].Number = 1;
set[2].Number = 1;
set[3].Number = 3;
set[4].Number = 3;
Assert.IsFalse(scoreCard.SLOT_YAHTZEE.Qualifier(set), "Is qualifiy on exactly 3");
}
}
// Small Straight
bool IsSmallStraight(DiceSet diceSet)
{
// Dice 1-4
if ((diceSet.HowManyOnes() == 1) && (diceSet.HowManyTwos() == 1) && (diceSet.HowManyThrees() == 1) &&
(diceSet.HowManyFours() == 1))
{
return(true);
}
// Dice 2-5
else if ((diceSet.HowManyTwos() == 1) && (diceSet.HowManyThrees() == 1) && (diceSet.HowManyFours() == 1) &&
(diceSet.HowManyFives() == 1))
{
return(true);
}
// Dice 3-6
else if ((diceSet.HowManyThrees() == 1) && (diceSet.HowManyFours() == 1) && (diceSet.HowManyFives() == 1) &&
(diceSet.HowManySixes() == 1))
{
return(true);
}
else
{
return(false);
}
}
private void createPlayer()
{
Random rand = new Random();
if (ID == 0)
{
ID = rand.Next(1, 1000);//Get an ID if if ID does not already exist
}
if (username == null)
{
username = "******";//Set username to Guest if it does not already exist
}
Player.Text = username;
if (cDS == null)
{
cDS = new DiceSet(0, empty); //Creates a defualt empty set if set does not exist
}
cDS.setPlayer(username, ID); //Set Player Current Dice Set
for (int i = 0; i < memory; i++)
{
if (dSA[i] == null)
{
dSA[i] = new DiceSet(0, empty); //Creates a defualt empty set if set does not exist
}
dSA[i].setPlayer(username, ID); //Set Player Dice Set Array
}
}
public void TestGetValues()
{
var diceSet = new DiceSet();
var values = diceSet.GetValues();
Assert.AreEqual(5, values.Length);
}
void diceFlashEffect()
{
m_fFlashTimeStamp += Time.deltaTime;
if (m_fFlashTimeStamp > GameData.FLASH_TIME)
{
m_bFlash = !m_bFlash;
m_fFlashTimeStamp = 0;
for (int i = 0; i < GameData.BOARD_SIZE_HEIGHT; ++i)
{
for (int j = 0; j < GameData.BOARD_SIZE_WIDTH; ++j)
{
DiceSet diceSet = GetDice(j, i);
if (diceSet != null && diceSet.script.GetState() == GameData.OBJECT_STATE_DISAPPEAR)
{
if (m_bFlash)
{
diceSet.script.doEffect(GameData.OBJECT_EFFECT_STATE_CLEAR_ON);
}
else
{
diceSet.script.doEffect(GameData.OBJECT_EFFECT_STATE_CLEAR_OFF);
}
}
}
}
}
}
void CheckDiceSide(int x, int y, int direction)
{
if (x >= 0 && y >= 0 && x < GameData.BOARD_SIZE_WIDTH && y < GameData.BOARD_SIZE_HEIGHT)
{
DiceSet diceSet = GetDice(x, y);
if (diceSet != null)
{
if (diceSet.script.GetDirection() == direction)
{
if (diceSet.checking == false)
{
if (diceSet.script.GetState() != GameData.OBJECT_STATE_APPEAR)
{
diceSet.checking = true;
m_aCheckDice.Add(diceSet);
CheckDiceSide(x + 1, y, direction);
CheckDiceSide(x - 1, y, direction);
CheckDiceSide(x, y + 1, direction);
CheckDiceSide(x, y - 1, direction);
}
}
}
}
}
}
public void TestDDStatRollerAllValuesCheck()
{
IRollable d = new DiceSet();
IRollable dd1 = DiceFactory.CreateDDStatRoller();
((DiceSet)d).Add(dd1);
// populate "not yet found" list
List <int> notFound = new List <int>();
notFound.AddRange(new int[] { 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18 });
// attempt to find each value
for (int i = 1; i < 1000; i++) // arbitrary limit of 10000 maximum tries
{
int result = d.Roll(); // 3 to 18
notFound.Remove(result);
if (notFound.Count <= 0)
{
break; // all found
}
}
// test
Assert.AreEqual <int>(0, notFound.Count, "Some values were not rolled on 3 d6.");
}
private void FreeDie_Click(object sender, RoutedEventArgs e)
{
DiceSet set = yahtzeeGame.DiceSet;
if (Dice1NButton == sender)
{
set[0].IsHeld = true;
}
else if (Dice2NButton == sender)
{
set[1].IsHeld = true;
}
else if (Dice3NButton == sender)
{
set[2].IsHeld = true;
}
else if (Dice4NButton == sender)
{
set[3].IsHeld = true;
}
else if (Dice5NButton == sender)
{
set[4].IsHeld = true;
}
updateDisplay();
}
private void HeldDie_Click(object sender, RoutedEventArgs e)
{
DiceSet set = yahtzeeGame.DiceSet;
if (Dice1HButton == sender)
{
set[0].IsHeld = false;
}
else if (Dice2HButton == sender)
{
set[1].IsHeld = false;
}
else if (Dice3HButton == sender)
{
set[2].IsHeld = false;
}
else if (Dice4HButton == sender)
{
set[3].IsHeld = false;
}
else if (Dice5HButton == sender)
{
set[4].IsHeld = false;
}
updateDisplay();
}
private bool MeetsRequirements(DiceSet diceSet)
{
return(diceSet.Values
.GroupBy(v => v)
.Select(group => new { group.Key, Count = group.Count() })
.Any(group => group.Count >= 3));
}
public void TestLowerFullHouse()
{
DiceSet set = new DiceSet(new Random());
ScoreCard scoreCard = new ScoreCard();
{
set[0].Number = 1;
set[1].Number = 1;
set[2].Number = 1;
set[3].Number = 2;
set[4].Number = 2;
Assert.IsTrue(scoreCard.SLOT_FULL_HOUSE.Qualifier(set), "Failed to qualifiy");
int expected = 25;
int actual = scoreCard.SLOT_FULL_HOUSE.ScorePotential(set);
Assert.AreEqual(expected, actual, "Gave wrong score for exact");
}
{
set[0].Number = 1;
set[1].Number = 1;
set[2].Number = 3;
set[3].Number = 2;
set[4].Number = 2;
Assert.IsFalse(scoreCard.SLOT_FULL_HOUSE.Qualifier(set), "Failed to qualifiy");
}
}
// Start is called before the first frame update
void Start()
{
confirm.onClick.AddListener(TaskOnClick);
var weatherContainer = FindObjectOfType <WeatherContainer>();
foreach (var token in weatherContainer.TokenList)
{
if (token == WeatherToken.Snow)
{
GetRidOfSnow(1);
}
if (token == WeatherToken.Storm)
{
Wall.DowngradeWallBy(1);
}
if (token == WeatherToken.Rain)
{
GetRidOfRain(1);
}
}
weatherDice = RoundSystem.instance.GetWeatherDices();
RollDices(weatherDice);
ShowText(weatherDice);
}
public void ScoreManager_GivenUpperSectionScore_AddsScoreToUpperScoreManager()
{
Mock <IUpperScoreManager> mockUpperScoreManager = new Mock <IUpperScoreManager>();
Mock <ILowerScoreManager> mockLowerScoreManager = new Mock <ILowerScoreManager>();
Mock <IScoreCategoryCalculatorResolver> mockCaluclatorResolver = new Mock <IScoreCategoryCalculatorResolver>();
mockCaluclatorResolver.Setup(r => r.Resolve(It.IsAny <ScoreCategories>()))
.Returns <IScoreCategoryCalculator>(_ =>
{
var mockCaluclator = new Mock <IScoreCategoryCalculator>();
mockCaluclator.Setup(c => c.Calculate(It.IsAny <DiceSet>()))
.Returns(30);
return(mockCaluclator.Object);
});
IScoreManager manager = new ScoreManager.ScoreManager(
mockUpperScoreManager.Object,
mockLowerScoreManager.Object,
mockCaluclatorResolver.Object);
var scoreSection = new ScoreCategoryMetadata {
Type = ScoreCategories.Aces, Section = ScoreSections.Upper
};
var diceSet = DiceSet.Create(new int[] { 1, 2, 3, 4, 5 });
manager.AddScoring(new AddScoringRequest {
CategoryMetadata = scoreSection, diceSet = diceSet
});
mockUpperScoreManager.Verify(m => m.AddToScore(30), Times.Once);
}
private void addSet(object sender, RoutedEventArgs e)
{
string name = setName.Text.Trim();
if (name == "")
{
name = "Slot " + current.ToString();
}
int count;
try
{
count = Int32.Parse(diceAmount.Text);//Try to convert string to int for dice count
}
catch
{
errorMessage("Dice Count is an illegal input");
return;
}
if (count <= 0)
{
errorMessage("Dice Count is less than or equal to 0 which is an illegal input");
return;
}
createPlayer();
cDS = new DiceSet(count, name);//Creates a new dice set with user inputs
errorMessage("");
memoryName();
}
private void deleteSet(object sender, RoutedEventArgs e)
{
cDS = new DiceSet(0, empty); //Set current dice set to a basic dice set
dSA[current] = cDS; //Set current save slot to current dice set
memoryName();
display();
errorMessage("");
}
void ClearWaveEffect()
{
for (int i = 0; i < m_aWaveEffectCheckDice.Count; i++)
{
DiceSet ds = (DiceSet)m_aWaveEffectCheckDice[i];
ds.nEmitterType = DiceSet.EMITTER_TYPE_NONE;
}
}
public void TestGetCounts()
{
var diceSet = new DiceSet(3, 3, 1, 2, 5);
var counts = diceSet.GetCounts();
var expectedCounts = new[] { 0, 1, 1, 2, 0, 1, 0 };
CollectionAssert.AreEqual(expectedCounts, counts);
}
public void Test_rolling_the_dice_returns_a_set_of_integers_between_1_and_6()
{
DiceSet dice = new DiceSet();
dice.roll(5);
Assert.AreEqual(5, dice.Values.Length);
Assert.IsFalse(dice.Values.Any(i => i < 1 || i > 6), "values must be between 1 and 6");
}
private void Select5(object sender, RoutedEventArgs e)
{
dSA[current] = cDS; //Save the current dice set into current save slot
cDS = dSA[4]; //Set current dice set from save slot 4
int temp = current;
current = 4;
SelectMemory(temp, current);
}
public void Test_you_can_roll_different_numbers_of_dice()
{
DiceSet dice = new DiceSet();
dice.roll(3);
Assert.AreEqual(3, dice.Values.Length);
dice.roll(1);
Assert.AreEqual(1, dice.Values.Length);
}
public void DSTestIsEmpty()
{
bool expected = true;
int num = 4;
DiceSet dS = new DiceSet(num, "Set Name");
bool result = dS.isEmpty();
Assert.AreEqual(expected, result);
}
public void DSTestGetName()
{
string expected = "Name1";
int num = 5;
DiceSet dS = new DiceSet(num, "Name1");
string result = dS.getName();
Assert.AreEqual(expected, result);
}
private void ShowText(DiceSet weatherDice)
{
if (!weatherDice.weatherDice_Normal && !weatherDice.weatherDice_Advanced && !weatherDice.environmentalDice)
{
descriptionText.text = "Weit und breit ist keine einzige Wolke zu sehen";
return;
}
descriptionText.text = "Über der Insel braut sich ein Sturm zusammen";
ShowDamage();
}
public void AcesCalculator_GivenDiceSetWithNoAces_ReturnsZero()
{
IScoreCategoryCalculator calculator = new AcesScoreCalculator();
DiceSet diceSet = DiceSet.Create(new int[] { 6, 3, 2, 3, 4 });
var expected = 0;
var result = calculator.Calculate(diceSet);
Assert.Equal(expected, result);
}
public void AcesCalculator_GivenDiceSetWithAces_CalculatsCorrectScore()
{
IScoreCategoryCalculator calculator = new AcesScoreCalculator();
DiceSet diceSet = DiceSet.Create(new int[] { 1, 1, 2, 3, 4 });
var expected = 2;
var result = calculator.Calculate(diceSet);
Assert.Equal(expected, result);
}
public void FullHouseScoreCalculator_NotGivenFullHouse_ReturnsZero()
{
var diceSet = DiceSet.Create(new int[] { 5, 1, 3, 3, 3 });
var expected = 0;
var calculator = new FullHouseScoreCalculator();
var result = calculator.Calculate(diceSet);
Assert.Equal(expected, result);
}
private bool MeetsRequirements(DiceSet diceSet)
{
var groupedResults = diceSet.Values
.GroupBy(v => v)
.Select(group => new { group.Key, Count = group.Count() });
return(groupedResults.Count() == 2 &&
groupedResults.Any(g => g.Count == 3) &&
groupedResults.Any(g => g.Count == 2));
}
private void updateDice()
{
DiceSet set = yahtzeeGame.Player1State.DiceSet;
updateGameDie(set[0], Dice1NButton, Dice1HButton, yahtzeeGame.Player1State);
updateGameDie(set[1], Dice2NButton, Dice2HButton, yahtzeeGame.Player1State);
updateGameDie(set[2], Dice3NButton, Dice3HButton, yahtzeeGame.Player1State);
updateGameDie(set[3], Dice4NButton, Dice4HButton, yahtzeeGame.Player1State);
updateGameDie(set[4], Dice5NButton, Dice5HButton, yahtzeeGame.Player1State);
}
public void RemoveDice(int x, int y)
{
DiceSet _diceSet = GetDice(x, y);
if (_diceSet != null)
{
_diceSet.script.Remove();
DestroyDice(5, 1);
}
}
