public ViewResult RsvpForm(GuessResponse guessResponse)
{
if (ModelState.IsValid)
{
Repository.AddResponse(guessResponse);
return(View("Thanks", guessResponse));
}
else
{
return(View());
}
}
public void UpdateMine(Guess guess, GuessResponse response)
{
var tile = _tiles.FirstOrDefault(t => t.Guess == guess);
if (tile != null && !response.Outcome.Equals("bomb"))
{
tile.Type = TileType.Money;
Invalidate();
}
if (!string.IsNullOrWhiteSpace(response.Bombs))
{
ShowHiddenMines(response.Bombs);
}
}
public void botGuess()
{
if (!_games.Keys.Contains(Context.ConnectionId))
{
Clients.Client(Context.ConnectionId).postHistory("Error", "Start a new game before sending guesses");
return;
}
GameData gameData = _games[Context.ConnectionId];
string guess;
if (gameData.previousAttempts.Count == 0)
{
guess = "11112233"; // Fixed first guess;
}
else
{
MastermindFitnessCalculator mastermindFitnessCalculator = new MastermindFitnessCalculator();
mastermindFitnessCalculator.setPreviousAttempts(gameData.previousAttempts);
GeneticAlgorithm ga = new GeneticAlgorithm(mastermindFitnessCalculator);
char[] guessArray = ga.calculateNextGuess(20);
guess = new string(guessArray);
}
GuessRequest request = new GuessRequest()
{
game_key = _games[Context.ConnectionId].game_key, code = AxiomzenMastermind.convertGuess(guess)
};
GuessResponse response = AxiomzenMastermind.guess(request);
gameData.previousAttempts.Add(new Attempt()
{
Guess = guess.ToCharArray(), Exact = response.result.exact, Near = response.result.near
});
Clients.Client(Context.ConnectionId).postHistory("Guess", string.Format("Code: {0}, Exact: {1}, Near: {2}, Attempts: {3}", guess, response.result.exact, response.result.near, response.num_guesses));
if (response.solved)
{
Clients.Client(Context.ConnectionId).postHistory("Congratulations!", "You guessed the secret code!");
}
}
/// <summary>
/// 向双方同时发送猜测结果
/// </summary>
/// <param name="data"></param>
private void _GuessResponse(Message message)
{
GuessResponse guessResponse = message.Guessresponse;
bool destroyed = guessResponse.Destroyed;
PlaneLocator planeLocator = guessResponse.Loc;
List <ChessBoard.Chessboard_Point> points = GameUtils.PlaneLocator_To_Points(planeLocator);
if (GameUtils.GetGameStatus() == ClientInfo.game_status.rival_guessing)
{
foreach (ChessBoard.Chessboard_Point point in points)
{
if (destroyed)
{
point.state = ChessBoard.point_state.destroy;
}
else
{
point.state = ChessBoard.point_state.miss;
}
ClientInfo.my_points.Enqueue(point);
}
GameUtils.SetGameStatus(ClientInfo.game_status.self_guessing);
}
else if (GameUtils.GetGameStatus() == ClientInfo.game_status.self_guessing)
{
foreach (ChessBoard.Chessboard_Point point in points)
{
if (destroyed)
{
point.state = ChessBoard.point_state.destroy;
}
else
{
point.state = ChessBoard.point_state.miss;
}
ClientInfo.rival_points.Enqueue(point);
}
GameUtils.SetGameStatus(ClientInfo.game_status.rival_guessing);
}
}
public static GuessResponse guess(GuessRequest guessRequest)
{
try
{
string url = serviceUrl + "guess?game_key=" + guessRequest.game_key
+ "&code=" + guessRequest.code;
HttpWebRequest request = WebRequest.Create(url) as HttpWebRequest;
request.Method = "POST";
request.ContentType = "text/json";
using (var streamWriter = new StreamWriter(request.GetRequestStream()))
{
DataContractJsonSerializer jsonResponseSerializer = new DataContractJsonSerializer(typeof(GuessRequest));
jsonResponseSerializer.WriteObject(streamWriter.BaseStream, guessRequest);
streamWriter.Flush();
streamWriter.Close();
}
using (HttpWebResponse response = request.GetResponse() as HttpWebResponse)
{
if (response.StatusCode != HttpStatusCode.OK)
{
throw new Exception(String.Format("Server error (HTTP {0}: {1}).", response.StatusCode, response.StatusDescription));
}
DataContractJsonSerializer jsonResponseSerializer = new DataContractJsonSerializer(typeof(GuessResponse));
object objResponse = jsonResponseSerializer.ReadObject(response.GetResponseStream());
GuessResponse jsonResponse = objResponse as GuessResponse;
return(jsonResponse);
}
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(null);
}
}
public void sendGuess(string guess)
{
if (!_games.Keys.Contains(Context.ConnectionId))
{
Clients.Client(Context.ConnectionId).postHistory("Error", "Start a new game before sending guesses");
return;
}
int guessInt;
if (guess.Length != 8 || !int.TryParse(guess, out guessInt))
{
Clients.Client(Context.ConnectionId).postHistory("Error", "Wrong guess format, must be 8 digit code, with values from 1 to 8");
return;
}
GuessRequest request = new GuessRequest()
{
game_key = _games[Context.ConnectionId].game_key, code = AxiomzenMastermind.convertGuess(guess)
};
GuessResponse response = AxiomzenMastermind.guess(request);
GameData gameData = _games[Context.ConnectionId];
gameData.previousAttempts.Add(new Attempt()
{
Guess = guess.ToCharArray(), Exact = response.result.exact, Near = response.result.near
});
Clients.Client(Context.ConnectionId).postHistory("Guess", string.Format("Code: {0}, Exact: {1}, Near: {2}, Attempts: {3}", guess, response.result.exact, response.result.near, response.num_guesses));
if (response.solved)
{
Clients.Client(Context.ConnectionId).postHistory("Congratulations!", "You guessed the secret code!");
}
}
public async Task <JsonResult> Post([FromBody] GuessRequestBody requestBody)
{
JsonResult response;
try
{
GuessResponse guessResponse = new GuessResponse()
{
RequestId = requestContext.RequestId
};
if (!gameContext.CurrentPhase.Equals(PhaseType.Running))
{
throw new GameNotInRunningPhaseException();
}
if (gameContext.Participants.Where(p => p.TeamId == User.Identity.Name && p.IsAlive != null && p.IsAlive == true).FirstOrDefault() == null)
{
throw new TeamNotJoinedException();
}
var guesses = requestBody.Guesses;
var body = PreProcess(requestBody);
var validatedBody = Validate(body, User.Identity.Name);
await Evaluate(validatedBody);
await CommitGuess(validatedBody, requestBody);
guessResponse.Data = new GuessResponseData {
Guesses = validatedBody.Guesses,
GameId = gameContext.GameId,
RoundId = gameContext.RoundId,
RoundNumber = gameContext.RoundNumber,
Status = gameContext.CurrentPhase.ToString()
};
response = new JsonResult(guessResponse)
{
StatusCode = 200
};
}
catch (GuessLimitExceededException)
{
response = new JsonResult(new GuessResponse
{
RequestId = requestContext.RequestId,
Err = new Error
{
Message = "Guess Limit Exceeded",
Description = $"At max {MAX_GUESSES} guesses are allowd at a time"
}
})
{
StatusCode = 400
};
}
catch (GameNotInRunningPhaseException)
{
response = new JsonResult(new GuessResponse
{
RequestId = requestContext.RequestId,
Err = new Error
{
Message = "Game is not in running phase",
Description = "/guess api requests are only accepted in Running phase"
}
})
{
StatusCode = 400
};
}
catch (TeamNotJoinedException)
{
response = new JsonResult(new GuessResponse
{
RequestId = requestContext.RequestId,
Err = new Error
{
Message = "Team not alive or joined",
Description = "Either you have not joined this round or your team is dead."
}
})
{
StatusCode = 400
};
}
catch (InvalidDataProvidedException)
{
response = new JsonResult(new GuessResponse
{
RequestId = requestContext.RequestId,
Err = new Error
{
Message = "Invalid Request Body",
Description = "Please provide a proper body for the api"
}
})
{
StatusCode = 400
};
}
catch (Exception)
{
logger.LogError($"Error Occurred while fetching current gamestatus");
response = new JsonResult(new GuessResponse
{
RequestId = requestContext.RequestId,
Err = new Error
{
Message = "Internal Server Error",
Description = "Server Failed to fetch Current Gamestatus"
}
})
{
StatusCode = 500
};
}
return(response);
}
protected virtual void OnGuessResponse(object source, EventArgs e)
{
GuessResponse?.Invoke(source, e);
}
