public GameObject Create(GuessResult cardResult)
{
GameObject resultGo = Instantiate(gameObject);
CardResultTile newCardRes = resultGo.GetComponent <CardResultTile>();
newCardRes.guessedImage.sprite = cardResult.imageGuessed;
newCardRes.resultText.text = cardResult.resultText;
newCardRes.amountText.text = cardResult.amount;
if (cardResult.resourceUsed == ResourceItem.Ductape)
{
newCardRes.resourceImage.sprite = tapeSprite;
}
if (cardResult.resourceUsed == ResourceItem.Wd)
{
newCardRes.resourceImage.sprite = wdSprite;
}
if (cardResult.correct)
{
newCardRes.amountText.color = GameConstantsBucket.ResourceColorPositive;
}
else
{
newCardRes.amountText.color = GameConstantsBucket.ResourceColorNegative;
}
return(resultGo);
}
// OO: Nice method :)
// OO: Your next step is to create tests for Hangman
static void Main(string[] args)
{
h.CreateCurrentHangman();
//PrintHangman(h.getCurrentHangman());
//PrintGuessesLeft(h.getNrOfGuesses());
while (!GameOver)
{
// Nytt yusri
Console.SetCursorPosition(6, 2);
PrintHangman(h.getCurrentHangman()); // -------
PrintGuessesLeft(h.getNrOfGuesses()); // gissningar kvar
PrintYourGuesses(h.getGuessedLetters()); // gissade bokstäver
Console.Write(" Message: ");
PrintMessage(result);
Console.Write(" Enter your guess: ");
result = h.Guess(Console.ReadLine().ToUpper());
//PrintMessage(result);
Console.Clear();
WinOrLose(h);
//if (!GameOver)
//{
// PrintGuessesLeft(h.getNrOfGuesses());
//}
}
}
private static void Play(Game game)
{
var guessService = new GuessService();
GuessResult result = null;
Console.WriteLine($"Gissa ett tal mellan {game.MinRandomNumber} och {game.MaxRandomNumber}");
while (game.GameState == GameState.OnGoing)
{
var guesses = new List <int>();
for (var i = 0; i < game.Players; i++)
{
Console.WriteLine($"Spelare {i + 1} gissar");
guesses.Add(ReadInteger(game.MinRandomNumber, game.MaxRandomNumber));
}
result = guessService.Guess(GuessModel.Create(game, guesses.ToArray()));
if (game.GameState == GameState.OnGoing)
{
Console.WriteLine($"Spelare {result.PlayerId} var närmast");
}
}
Console.WriteLine($"Spelare {result.PlayerId} vann och var närmast {game.CorrectNumber}");
}
/// <summary>
/// Check the guess against the random number
/// </summary>
protected virtual GuessResult guessResult(int guess, out int remainingGuesses)
{
GuessResult retval = GuessResult.Fail;
try
{
if (--_CurrentGuessNumber == 0)
{
retval = GuessResult.Incorrect;
}
else
{
retval = guess > _RandomNumber ? GuessResult.Higher :
guess < _RandomNumber ? GuessResult.Lower :
GuessResult.Correct;
}
remainingGuesses = _CurrentGuessNumber;
return(retval);
}
catch (Exception ex)
{
//TBD. Log the exception
remainingGuesses = _CurrentGuessNumber;
return(GuessResult.Fail);
}
}
public void guess_should_be_correct()
{
var h = new Core.Hangman("Sommar", 6);
GuessResult result = h.Guess("M");
Assert.AreEqual(GuessResult.CorrectGuess, result);
}
private void Crack(Combination combination, string guess, Solution solution, List <string> possibilities)
{
GuessResult baseResult = combination.Try(guess);
solution.Guesses.Add(guess);
if (baseResult.WasRight)
{
solution.Answer = guess;
return;
}
// I'm going to modify the collection, with that in mind we won't use
// a foreach loop.
for (int i = 0; i < possibilities.Count; i++)
{
GuessResult result = combination.Try(guess, possibilities[i]);
if (!result.Equals(baseResult))
{
possibilities.Remove(possibilities[i]);
i--;
}
}
}
public static void DisplayGuessMessage(GuessResult result)
{
switch (result)
{
case GuessResult.Invalid:
DisplayInvalid();
break;
case GuessResult.Lower:
DisplayLower();
break;
case GuessResult.Higher:
DisplayHigher();
break;
case GuessResult.Victory:
DisplayVictory();
break;
default:
Console.WriteLine("The number you entered was invalid. Try entering a number between 1 and 20");
break;
}
}
public static void DisplayGuessMessagae(GuessResult result)
{
string message = String.Empty;
switch (result)
{
case GuessResult.Invalid:
//Since this message includes the valid range, get the range from the manager
message = $"That guess wasn't valid, try something between {GameManager.MinimumGuess} and {GameManager.MaximumGuess}.";
break;
case GuessResult.Higher:
message = "Your guess was too low, try something higher.";
break;
case GuessResult.Lower:
message = "Your guess was too high, try something lower.";
break;
case GuessResult.Victory:
message = "You did it! You are awesome!";
break;
}
Console.WriteLine(message);
//Parameter not specified and uses default value
PressKeyToContinue();
}
private static GuessResult GetGuessResult(string number, string guess)
{
var result = new GuessResult();
var isGuessVisited = new bool[number.Length];
var isNumVisited = new bool[number.Length];
for (int i = 0; i < number.Length; i++)
{
if (number[i] == guess[i])
{
result.Bulls += 1;
isGuessVisited[i] = true;
isNumVisited[i] = true;
}
}
for (int i = 0; i < number.Length; i++)
{
for (int j = 0; j < guess.Length; j++)
{
if (i != j && !isNumVisited[j] && !isGuessVisited[i] && guess[i] == number[j])
{
result.Cows += 1;
isGuessVisited[i] = true;
isNumVisited[j] = true;
}
}
}
return(result);
}
/// <summary>
/// Occurs when a player that is playing in the bot makes a guess.
/// Inform the bot of what was the player's guess, and the guess results (exact and near matches).
/// </summary>
/// <param name="round">Number of current round of the game.</param>
/// <param name="result">a <c>GuessResult</c> object representing the result of a players guess.</param>
private void SendGuessToBot(int round, GuessResult result)
{
AxiomBot bot = new AxiomBot();
var rowIndex = round - 2;
bot.SetResult(rowIndex, result);
}
/// <summary>
/// Set the results of a player guess. Must be called on each round that the user plays.
/// </summary>
/// <param name="rowIndex">The current round the game is (Zero based index)</param>
/// <param name="result">The result of the user's guess</param>
internal void SetResult(int rowIndex, GuessResult result)
{
if (rowIndex == 0)
{
Grid = new int[8, 100];
Pegs = new int[8, 100];
}
int[] pegs = new int[8];
int idx = 0;
for (int i = 0; i < result.Exactly; i++)
{
pegs[idx] = 1;
idx++;
}
for (int i = 0; i < result.Near; i++)
{
pegs[idx] = 2;
idx++;
}
for (int i = 0; i < 8 - result.Exactly - result.Near; i++)
{
pegs[idx] = 0;
idx++;
}
for (int i = 0; i < 8; i++)
{
int gridValue = Convert.ToInt32(result.Guess[i].ToString());
Grid[i, rowIndex] = gridValue;
Pegs[i, rowIndex] = pegs[i];
}
CurrentRow = rowIndex;
}
public void MyTestMethod3()
{
var h = new Hangman("UTEPILS");
GuessResult result = h.Guess('#');
Assert.AreEqual(GuessResult.InvalidGuess, result);
}
public void MakeNewGuess()
{
guesses++;
GuessResult result = Guess();
HandleResult(result);
}
public void Evaluate_ShouldPassTestCases(string secret, string input, int expectedWellPlaced, int expectedMisplaced)
{
GuessResult result = App.Eval(StringToColours(secret), StringToColours(input));
//Assert
Assert.Equal(expectedWellPlaced, result.WellPlaced);
Assert.Equal(expectedMisplaced, result.Misplaced);
}
/// <summary>
/// 推理を行う
/// </summary>
protected virtual void Guess()
{
GuessStrategyArgs args = new GuessStrategyArgs {
Agi = agi
};
LatestGuess = new GuessResultExt(hasGuessStrategy, args);
}
public void MyTestMethod()
{
var h = new Hangman("UTEPILS");
GuessResult result = h.Guess('E');
Assert.AreEqual(GuessResult.CorrectGuess, result);
}
public void GuessResultTest(int guess, GuessResult expected)
{
GuessManager mgr = new GuessManager();
mgr.Start(10);
var actual = mgr.ProcessGuess(guess);
Assert.AreEqual(expected, actual);
}
public void TestMethod1()
{
// Arrange
var guessResult = new GuessResult();
// Act
// Assert
Assert.Fail();
}
public void should_return_InvalidGuess_when_guessing_a_multiple_letters_or_any_string()
{
// Arrange
var hangman = new Hangman("KALLE", 3);
// Act
GuessResult result = hangman.Guess("abcd");
// Assert
Assert.AreEqual(GuessResult.InvalidGuess, result);
}
public void guess_should_be_invalid()
{
var h = new Core.Hangman("Sommar", 6);
GuessResult result = h.Guess("ma");
Assert.AreEqual(GuessResult.InvalidGuess, result);
result = h.Guess(".");
Assert.AreEqual(GuessResult.InvalidGuess, result);
}
public void should_return_InvalidGuess_when_guessing_a_number_or_any_sign()
{
// Arrange
var hangman = new Hangman("KALLE", 3);
// Act
GuessResult result = hangman.Guess("4");
// Assert
Assert.AreEqual(GuessResult.InvalidGuess, result);
}
public void LowerGuessTest()
{
GameManager gm = new GameManager();
gm.Start(15);
GuessResult actual = gm.ProcessGuess(19);
Assert.AreEqual(GuessResult.Lower, actual);
}
public void should_return_CorrectGuess_when_guessing_A()
{
// Arrange
var hangman = new Hangman("KALLE", 3);
// Act
GuessResult result = hangman.Guess("A");
// Assert
Assert.AreEqual(GuessResult.CorrectGuess, result);
}
public void VictoryGuessTest()
{
GameManager gm = new GameManager();
gm.Start(15);
GuessResult actual = gm.ProcessGuess(15);
Assert.AreEqual(GuessResult.Victory, actual);
}
public void InvalidGuessTest()
{
GameManager gm = new GameManager();
gm.Start();
GuessResult actual = gm.ProcessGuess(130);
Assert.AreEqual(GuessResult.Invalid, actual);
}
public void MyTestMethod2()
{
var h = new Hangman("UTEPILS");
GuessResult result1 = h.Guess('E');
GuessResult result2 = h.Guess('E');
Assert.AreEqual(GuessResult.CorrectGuess, result1);
Assert.AreEqual(GuessResult.AlreadyGuessed, result2);
}
public void VictoryGuessResultTest()
{
GameManager gameInstance = new GameManager();
gameInstance.Start(10);
GuessResult actual = gameInstance.ProcessGuess(10);
Assert.AreEqual(GuessResult.Victory, actual);
}
public void GuessResultTest(int guess, GuessResult expected)
{
GameManager gameInstance = new GameManager();
gameInstance.Start(10);
GuessResult actual = gameInstance.ProcessGuess(10);
Assert.AreEqual(expected, actual);
}
public void InvalidGuessTest()
{
GameManager gameInstance = new GameManager();
gameInstance.Start();
GuessResult actual = gameInstance.ProcessGuess(152);
Assert.AreEqual(GuessResult.Invalid, actual);
}
public void HigherGuessResultTest()
{
GameManager gameInstance = new GameManager();
gameInstance.Start(10);
GuessResult actual = gameInstance.ProcessGuess(8);
Assert.AreEqual(GuessResult.Higher, actual);
}
protected override void DoGuess(string phrase, GuessResult result, NetworkSetting networkSetting)
{
string query_base = "http://ajax.googleapis.com/ajax/services/language/detect?" +
"v=1.0&hl=en&q=";
int allowed_length = 2070 - query_base.Length;
string query = SplitQuery(phrase, allowed_length);
if(query.Length > 500)
throw new InvalidOperationException("The length of string is greater of 500 characters." +
" string : " + query +
", full phrase : " + phrase
);
string real_query = query_base + HttpUtility.UrlEncode(query);
if(real_query.Length > 2070)
throw new InvalidOperationException("The length of query is greater of 2070 characters." +
" query : " + real_query +
" full phrase : " + phrase
);
WebRequestHelper helper =
new WebRequestHelper(result, new Uri(real_query),
networkSetting,
WebRequestContentType.UrlEncodedGet,
true);
helper.Referer = "http://translate-net.appspot.com/";
string responseFromServer = helper.GetResponse();
if(responseFromServer.Contains(", \"responseStatus\": 200}"))
{
string languageString = StringParser.Parse("\"language\":\"", "\"", responseFromServer);
string isReliableString = StringParser.Parse("\"isReliable\":", ",", responseFromServer);
string confidenceString = StringParser.Parse("\"confidence\":", "}", responseFromServer);
Language language;
if(languageString == "pt-PT")
language = Language.Portuguese;
else
{
if(!keyToLang.TryGetValue(languageString, out language))
throw new TranslationException("Language : " + languageString + " not supported");
}
bool isReliable = isReliableString == "true";
//if(phrase.Length < 30)
// isReliable = false;
NumberFormatInfo num = NumberFormatInfo.InvariantInfo;
confidenceString = confidenceString.Replace(",", num.NumberDecimalSeparator);
confidenceString = confidenceString.Replace(".", num.NumberDecimalSeparator);
double confidence;
if(!double.TryParse(confidenceString,NumberStyles.Number | NumberStyles.AllowExponent, num, out confidence))
throw new TranslationException("Can't parse string : " + confidenceString + " to float");
result.AddScore(language, confidence*100, isReliable);
}
else
{
string error = StringParser.Parse("\"responseDetails\": \"", "\"", responseFromServer);
string code = StringParser.Parse("\"responseStatus\":", "}", responseFromServer);
throw new TranslationException(error + ", error code : " + code);
}
}
internal GuessCompletedEventArgs(
AsyncGuessState guessState,
Exception e,
bool canceled,
object state)
: base(e, canceled, state)
{
this.guessState = guessState;
this.result = guessState.Result;
}
static void AddToCache(GuessResult result)
{
int minimalCacheLength = TranslateOptions.Instance.GuessingOptions.MinimalTextLengthForSwitchByLanguage;
if(result.Phrase.Length < minimalCacheLength || !result.IsReliable)
return;
lock(cache)
{
if(cache.Count > 0 && cache[0] == result)
return;
cache.Remove(result);
cache.Insert(0, result);
if(cache.Count > 10)
cache.RemoveAt(10);
}
}
public static GuessResult GetCachedGuessResult(LanguageGuesser serviceItem, string phrase)
{
if(!useCache)
return new GuessResult(serviceItem, phrase);
string key = phrase.Trim().ToLowerInvariant();
if(key.Length > 300)
key = key.Substring(0, 300);
GuessResultsHashtable collection;
bool collection_exists = true;
lock(cache)
{
if(!cache.TryGetValue(key, out collection))
{
collection = new GuessResultsHashtable();
cache.Add(key, collection);
collection_exists = false;
}
}
int hash = serviceItem.FullName.GetHashCode();
bool needed_new_result = !collection_exists;
GuessResult res = null;
lock(collection)
{
if(!needed_new_result)
{
if(!collection.TryGetValue(hash, out res))
needed_new_result = true;
else
{
needed_new_result = (res.Error != null && !res.ResultNotFound) || res.Phrase != phrase;
}
}
if(needed_new_result)
{
res = new GuessResult(serviceItem, phrase);
collection[hash] = res;
lock(results_history)
{
results_history.Add(res);
}
}
else
{
res.LastUsed = DateTime.Now;
lock(results_history)
{
results_history.Remove(res);
results_history.Add(res);
}
}
}
return res;
}
protected abstract void DoGuess(string phrase, GuessResult result, NetworkSetting networkSetting);
