public Game RetrieveGame(string name, bool retrieveAssociations)
{
using (var db = new ConquestionDBContext())
{
if (retrieveAssociations != true)
{
Game chosenGame = db.Games.AsNoTracking()
.Where(x => x.Name.Equals(name))
.FirstOrDefault();
return(chosenGame);
}
else
{
Game chosenGame = db.Games.AsNoTracking()
.Include("Players")
.Include("QuestionSet.Questions.Answers")
.Include("Rounds.Question.Answers")
.Include("Rounds.PlayerAnswers")
.Where(x => x.Name.Equals(name))
.FirstOrDefault();
return(chosenGame);
}
}
}
public void AddPlayer(Game game, Player player)
{
using (var db = new ConquestionDBContext())
{
var gameEntity = db.Games.Include("Players").Where(g => g.Name.Equals(game.Name)).FirstOrDefault();
var playerEntity = db.Players.Where(p => p.Name.Equals(player.Name)).FirstOrDefault();
if (gameEntity != null)
{
if (gameEntity.Players == null)
{
gameEntity.Players = new List <Player>();
}
if (!gameEntity.Players.Contains(playerEntity))
{
gameEntity.Players.Add(playerEntity);
db.Entry(gameEntity).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
}
}
else
{
throw new Exception();
}
}
}
public bool StartGame(Game game, Player player)
{
using (var db = new ConquestionDBContext())
{
var gameEntity = db.Games.Include("Players").Where(g => g.Id == game.Id).FirstOrDefault();
var playerEntity = db.Players.Where(p => p.Name.Equals(player.Name)).FirstOrDefault();
if (playerEntity.Name.Equals(gameEntity.Players[0].Name) && gameEntity.GameStatus.Equals(Game.GameStatusEnum.starting))
{
gameEntity.GameStatus = Game.GameStatusEnum.ongoing;
gameEntity.Rounds = new List <Round>();
Round firstRound = new Round {
RoundNo = 1, QuestionStartTime = DateTime.Now
};
var randQuestion = roundCtr.RetrieveRandomQuestion(gameEntity);
var questionEntity = db.Questions.Include("Answers").Where(r => r.Id == randQuestion.Id).FirstOrDefault();
firstRound.Question = questionEntity;
gameEntity.Rounds.Add(firstRound);
db.Entry(gameEntity).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
return(true);
}
else
{
return(false);
}
}
}
public Player RetrievePlayer(string name)
{
using (ConquestionDBContext db = new ConquestionDBContext())
{
return(db.Players.Where(p => p.Name.Equals(name)).FirstOrDefault());
}
}
public Game CreateGame(Game game, String questionSet, int noOfRounds)
{
using (var db = new ConquestionDBContext())
{
if (!ActiveGamesNames().Contains(game.Name))
{
game.GameStatus = Game.GameStatusEnum.starting;
game.QuestionSet = db.QuestionSets.Include("Questions").Include("Questions.Answers").Where(q => q.Title == questionSet).FirstOrDefault();
game.NoOfRounds = noOfRounds;
db.Games.Add(game);
db.SaveChanges();
var askedQuestionEntity = db.AskedQuestions.Where(q => q.GameId == game.Id).ToList();
var allQuestionsEntity = db.Questions.Include("Answers").Where(q => q.QuestionSetId == game.QuestionSet.Id).ToList();
if (askedQuestionEntity.Count == 0)
{
foreach (Question q in allQuestionsEntity)
{
db.AskedQuestions.Add(new AskedQuestion {
GameId = game.Id, QuestionId = q.Id, HasBeenAsked = false
});
db.SaveChanges();
}
}
return(game);
}
else
{
throw new Exception("Game name is already taken, please select an unique name.");
}
}
}
//Definitely Keep
public QuestionSet RetrieveQuestionSet(int id)
{
using (var db = new ConquestionDBContext())
{
var questionSet = db.QuestionSets.Include("Questions.Answers").Where(x => x.Id == id).FirstOrDefault();
return(questionSet);
}
}
public QuestionSet RetrieveQuestionSetByTitle(string title)
{
using (var db = new ConquestionDBContext())
{
var questionSet = db.QuestionSets.Include("Questions.Answers").Where(x => x.Title.Equals(title)).FirstOrDefault();
return(questionSet);
}
}
public void DeleteQuestionSet(QuestionSet questionSet)
{
using (var db = new ConquestionDBContext())
{
db.QuestionSets.Remove(questionSet);
db.SaveChanges();
}
}
public bool ValidateAnswer(Answer answer)
{
using (var db = new ConquestionDBContext())
{
bool success = db.Answers.AsNoTracking().Where(a => a.Id == answer.Id).FirstOrDefault().IsValid;
return(success);
}
}
public Player RetrieveRoundWinner(Round round)
{
using (var db = new ConquestionDBContext())
{
var rEntity = db.Rounds.Include("RoundWinner").Where(r => r.Id == round.Id).FirstOrDefault();
return(rEntity.RoundWinner);
}
}
//Definitely Keep
public List <QuestionSet> RetrieveAllQuestionSets()
{
using (var db = new ConquestionDBContext())
{
var questionSet = db.QuestionSets.Include("Questions.Answers").ToList();
return(questionSet);
}
}
public Player CreatePlayer(Player player)
{
using (var db = new ConquestionDBContext())
{
db.Players.Add(player);
db.SaveChanges();
return(player);
}
}
//Definitely Keep
public QuestionSet CreateQuestionSet(QuestionSet questionSet)
{
using (var db = new ConquestionDBContext())
{
db.QuestionSets.Add(questionSet);
db.SaveChanges();
return(questionSet);
}
}
public void CreateRound(Game game)
{
using (ConquestionDBContext db = new ConquestionDBContext())
{
using (var transaction = db.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
{
// Should be ok
try
{
var gameEntity = db.Games.Include("Players").Include("QuestionSet.Questions.Answers").Include("Rounds.Question.Answers")
.Where(x => x.Id.Equals(game.Id))
.FirstOrDefault();
if (gameEntity.Rounds.Count < gameEntity.NoOfRounds)
{
//Check if rounds list has been initialised
if (gameEntity.Rounds == null)
{
gameEntity.Rounds = new List <Round>();
}
// if there are rounds get the count and set the round number to the count + 1
int?noOfRounds = gameEntity.Rounds.Count();
var newRound = new Round();
if (noOfRounds == null || noOfRounds == 0)
{
newRound.RoundNo = 1;
}
else
{
newRound.RoundNo = (int)noOfRounds + 1;
}
newRound.QuestionStartTime = DateTime.Now;
var question = RetrieveRandomQuestion(gameEntity);
var questionEntity = db.Questions.Include("Answers").Where(q => q.Id == question.Id).FirstOrDefault();
newRound.Question = questionEntity;
gameEntity.Rounds.Add(newRound);
db.Entry(gameEntity).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
}
else
{
}
transaction.Commit();
}
catch (Exception)
{
//Explicity dont rollback here because we expect deadlock situations which will be solved by SQL server auto rollbacking no need to here.
// transaction.Rollback();
}
}
}
}
public List <Game> RetrieveActiveGames()
{
using (var db = new ConquestionDBContext())
{
List <Game> activeGames = new List <Game>();
activeGames = db.Games.Where(g => g.GameStatus == Game.GameStatusEnum.starting).ToList();
return(activeGames);
}
}
public List <string> ActiveGamesNames()
{
using (var db = new ConquestionDBContext())
{
List <Game> activeGames = new List <Game>();
activeGames = db.Games.Where(g => g.GameStatus == Game.GameStatusEnum.starting).ToList();
List <string> activeGamesNames = new List <string>();
foreach (Game g in activeGames)
{
activeGamesNames.Add(g.Name);
}
return(activeGamesNames);
}
}
//To see if everyone has answered in this round
public bool CheckIfAllPlayersAnswered(Game game, Round round)
{
using (var db = new ConquestionDBContext())
{
bool allPlayersAnswered = false;
int noOfPlayers = game.Players.Count;
var raEntity = db.Rounds.Include("PlayerAnswers").Where(ra => ra.Id == round.Id).FirstOrDefault();
int? noOfAnswers = raEntity.PlayerAnswers?.Count;
if (noOfPlayers == noOfAnswers)
{
allPlayersAnswered = true;
}
return(allPlayersAnswered);
}
}
public Question RetrieveRandomQuestion(Game game)
{
using (var db = new ConquestionDBContext())
{
var unaskedQuestion = db.AskedQuestions.AsNoTracking().Include("Question").Include("Question.Answers").Where(q => q.GameId == game.Id && q.HasBeenAsked == false).ToList();
AskedQuestion question = new AskedQuestion();
unaskedQuestion.Shuffle();
question = unaskedQuestion[0];
var askedQuestionEntity = db.AskedQuestions.Where(q => q.GameId == game.Id && q.QuestionId == question.QuestionId).FirstOrDefault();
askedQuestionEntity.HasBeenAsked = true;
db.Entry(askedQuestionEntity).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
return(question.Question);
}
}
public bool CheckPlayerAnswers(Game game, Round round)
{
using (var db = new ConquestionDBContext())
{
bool ready = false;
var gameEntity = db.Games.Include("Players").Where(g => g.Name.Equals(game.Name)).FirstOrDefault();
var roundActionEntity = db.Rounds.Include("PlayerAnswers").Where(p => p.Id == (round.Id)).FirstOrDefault();
while (gameEntity.Players.Count != roundActionEntity.PlayerAnswers.Count)
{
Console.WriteLine("waiting");
}
ready = true;
return(ready);
}
}
//not sure we need these
public void AddAnswersToAQuestion(Question question, List <Answer> answerList)
{
using (var db = new ConquestionDBContext())
{
if (question.Answers == null)
{
question.Answers = new List <Answer>();
}
foreach (Answer a in answerList)
{
question.Answers.Add(a);
}
db.Entry(question).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
}
}
//Not sure we need these
public void AddQuestionsToQuestionSet(QuestionSet questionSet, List <Question> questionlist)
{
using (var db = new ConquestionDBContext())
{
if (questionSet.Questions == null)
{
questionSet.Questions = new List <Question>();
}
foreach (Question q in questionlist)
{
questionSet.Questions.Add(q);
}
db.Entry(questionSet).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
}
}
public Player DetermineGameWinner(Game game)
{
using (var db = new ConquestionDBContext())
{
var roundsEntity = db.Games.Include("Rounds").Include("Players").Where(g => g.Id == game.Id).FirstOrDefault().Rounds.ToList();
try
{
var winner = roundsEntity.Where(r => r.RoundWinner != null).GroupBy(r => r.RoundWinner).OrderByDescending(r => r.Count()).ToList()
.First().Key;
return(winner);
}
catch (InvalidOperationException)
{
return(null);
}
}
}
public bool LeaveGame(Game game, Player player)
{
using (var db = new ConquestionDBContext())
{
var gameEntity = db.Games.Include("Players").Where(g => g.Id == game.Id).FirstOrDefault();
var playerEntity = db.Players.Where(p => p.Name.Equals(player.Name)).FirstOrDefault();
if (gameEntity != null && playerEntity != null)
{
gameEntity.Players.Remove(playerEntity);
db.Entry(gameEntity).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
return(true);
}
else
{
return(false);
}
}
}
public bool CheckIfGameIsFinished(Game game)
{
using (var db = new ConquestionDBContext())
{
bool finished = false;
Game gameEntity = db.Games.Include("Rounds").Include("Players").AsNoTracking().Where(g => g.Id == game.Id).FirstOrDefault();
int elapsedSeconds = (int)(DateTime.Now - gameEntity.Rounds.Last().QuestionStartTime).TotalSeconds;
if (gameEntity.Rounds.Count() == gameEntity.NoOfRounds)
{
if (roundCtr.CheckIfAllPlayersAnswered(gameEntity, gameEntity.Rounds.Last()) || elapsedSeconds == 30)
{
gameEntity.GameStatus = Game.GameStatusEnum.finished;
db.Entry(gameEntity).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
finished = true;
}
}
return(finished);
}
}
public void AddQuestionSet(Game game, QuestionSet questionSet)
{
using (var db = new ConquestionDBContext())
{
var gameEntity = db.Games.Where(g => g.Name.Equals(game.Name)).FirstOrDefault();
var questionSetEntity = db.QuestionSets.Where(q => q.Title.Equals(questionSet.Title)).FirstOrDefault();
if (gameEntity != null && questionSetEntity != null)
{
if (gameEntity.QuestionSet == null || gameEntity.QuestionSet.Title.Equals(""))
{
gameEntity.QuestionSet = questionSetEntity;
db.Entry(gameEntity).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
}
}
else
{
throw new Exception();
}
}
}
public void SubmitAnswer(Round round, PlayerAnswer playerAnswer)
{
using (var db = new ConquestionDBContext())
{
//This is important to compare to the question start time to see if the player answered in time.
playerAnswer.PlayerAnswerTime = DateTime.Now;
var playerEntity = db.Players.Where(p => p.Name.Equals(playerAnswer.Player.Name)).FirstOrDefault();
playerAnswer.Player = playerEntity;
var answerEntity = db.Answers.Where(a => a.Id == playerAnswer.AnswerGiven.Id).FirstOrDefault();
playerAnswer.AnswerGiven = answerEntity;
Round rEntity = db.Rounds.Include("PlayerAnswers.Player").Include("RoundWinner").Where(r => r.Id == round.Id).FirstOrDefault();
// Check is the list has been initialised, if not intialise it
if (rEntity.PlayerAnswers == null)
{
rEntity.PlayerAnswers = new List <PlayerAnswer>();
}
//Checking if the player answers in time and that they haven't already submitted an answer
int elapsedSeconds = (int)(playerAnswer.PlayerAnswerTime - rEntity.QuestionStartTime).TotalSeconds;
bool playerHasntAnswered = true;
if (rEntity.PlayerAnswers.Where(pa => pa.Player.Id == playerAnswer.Player.Id).FirstOrDefault() != null)
{
playerHasntAnswered = false;
}
//Saves the player's answer to the database
if (elapsedSeconds <= 35 && playerHasntAnswered)
{
rEntity.PlayerAnswers.Add(playerAnswer);
if (ValidateAnswer(playerAnswer.AnswerGiven) && rEntity.RoundWinner == null)
{
rEntity.RoundWinner = playerAnswer.Player;
}
db.Entry(rEntity).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
}
}
}
public int DetermineNoOfCorrectAnswers(Game game, Player player)
{
using (var db = new ConquestionDBContext())
{
int noOfCorrectAnswers = 0;
int correctAnswers = 0;
var playerAnwsersEntity = db.PlayerAnswers.Include("Round.Game").Include("Player").Include("AnswerGiven").ToList();
correctAnswers = 0;
foreach (PlayerAnswer pA in playerAnwsersEntity)
{
if (pA.Player.Id == player.Id && pA.AnswerGiven.IsValid == true && pA.Round.Game.Id == game.Id)
{
correctAnswers++;
}
}
noOfCorrectAnswers = correctAnswers;
return(noOfCorrectAnswers);
}
}
public bool JoinGame(Game game, Player player)
{
using (var db = new ConquestionDBContext())
{
bool success = false;
var playerEntity = db.Players.Where(p => p.Name.Equals(player.Name)).FirstOrDefault();
using (var transaction = db.Database.BeginTransaction(System.Data.IsolationLevel.Serializable))
{
try
{
var gameEntity = db.Games.Include("Players").Where(g => g.Id == game.Id).FirstOrDefault();
if (gameEntity != null && playerEntity != null)
{
if (gameEntity.Players.Count < 4)
{
gameEntity.Players.Add(playerEntity);
db.Entry(gameEntity).State = System.Data.Entity.EntityState.Modified;
db.SaveChanges();
//System.Threading.Thread.Sleep(5000);
transaction.Commit();
success = true;
}
else if (gameEntity.Players.Contains(playerEntity))
{
success = true;
}
}
}
catch (Exception)
{
transaction.Rollback();
}
}
return(success);
}
}
// Returns a list of players so we can display their names on the map screen and determine what map nodes they own
public List <Player> RetrieveAllPlayersByGameId(Game game)
{
using (var db = new ConquestionDBContext())
{
List <Player> foundPlayers = new List <Player>();
var gameEntity = db.Games.Include("Players").Where(g => g.Id == game.Id).FirstOrDefault();
if (gameEntity != null)
{
if (gameEntity.Players != null)
{
foundPlayers = gameEntity.Players;
}
else
{
throw new Exception();
}
}
else
{
throw new Exception();
}
return(foundPlayers);
}
}
