public List<GameModel> AllGames()
        {
            List<GameModel> ret = new List<GameModel>();

            using (ADayInTheLifeEntities db = new ADayInTheLifeEntities())
            {
                try
                {
                    List<Game> games = db.Games.ToList();

                    foreach(Game g in games)
                    {
                        GameModel gm = new GameModel()
                        {
                            GameId = g.GameId,
                            Players = g.Players,
                            WinCondition1 = g.WinCondition1,
                            WinCondition2 = g.WinCondition2,
                            WinCondition3 = g.WinCondition3,
                            WinCondition4 = g.WinCondition4
                        };

                        ret.Add(gm);
                    }
                }
                catch (Exception e)
                {
                    //TODOL: Log This
                }
            }

            return ret;
        }

        protected override void LoadContent()
        {
            var device = graphics.GraphicsDevice;

            spriteBatch = new SpriteBatch(GraphicsDevice);

            spaceship = new GameModel(Content.Load<Model>("spaceship"))
            {
                Position = new Vector3(0, 3500, 0),
                Scale = new Vector3(50f),
                BaseRotation = new Vector3(0, MathHelper.Pi, 0),
                Rotation = new Vector3(0, MathHelper.Pi, 0)
            };

            models.Add(spaceship);

            var effect = Content.Load<Effect>("BasicTerrainEffect");
            effect.Parameters["Texture"].SetValue(Content.Load<Texture2D>("grass"));

            ground = new Terrain(
                Content.Load<Texture2D>("heightmap1"),
                effect,
                30, 4800, device
                );

            models.Add(ground);

            camera = new ChaseCamera(
                new Vector3(0, 400, 1500),
                new Vector3(0, 200, 0),
                new Vector3(0, 0, 0),
                GraphicsDevice);
        }

 public override void Play(GameModel gameModel)
 {
     if (!gameModel.CardModifiers.OfType<HighwayCardModifier>().Any(m => m.Source == this))
     {
         gameModel.AddCardModifier(new HighwayCardModifier(this));
     }
 }

 public override void PlayAttack(GameModel gameModel, IEnumerable<Player> attackedPlayers)
 {
     foreach (Player player in attackedPlayers)
     {
         CardModel topCard = player.DrawCard();
         if (topCard != null)
         {
             if (topCard.Is(CardType.Victory))
             {
                 player.GainCard(typeof(Curse));
             }
             else
             {
                 gameModel.TextLog.WriteLine(player.Name + " reveals a " + topCard.Name + ".");
                 int choice = gameModel.CurrentPlayer.Chooser.ChooseOneEffect(EffectChoiceType.GainForJester, topCard, "Who gains a copy?", choices, choices);
                 if (choice == 0)
                 {
                     gameModel.CurrentPlayer.GainCard(topCard.GetType());
                 }
                 else
                 {
                     player.GainCard(topCard.GetType());
                 }
             }
             player.DiscardCard(topCard);
         }
     }
 }

 public override void PlayAttack(GameModel gameModel, IEnumerable<Player> attackedPlayers)
 {
     foreach(Player player in attackedPlayers)
     {
         player.HasHauntedWoodsEffect.Add(gameModel.CurrentPlayer);
     }
 }

 public override void PlayAttack(GameModel gameModel, IEnumerable<Player> attackedPlayers)
 {
     foreach (Player attacked in attackedPlayers)
     {
         this.DoAttack(gameModel.CurrentPlayer, attacked);
     }
 }

 public override void PlayAttack(GameModel gameModel, IEnumerable<Player> attackedPlayers)
 {
     foreach (Player player in attackedPlayers)
     {
         player.GainCard(gameModel.Ruins);
     }
 }

 public override void BeforePlay(GameModel gameModel)
 {
     if (this.mimic == null)
     {
         CardModel target = null;
         if (this.forceMimic != null)
         {
             target = this.forceMimic;
         }
         else
         {
             Pile pile = gameModel.CurrentPlayer.Chooser.ChooseOnePile(CardChoiceType.BandOfMisfits, "Play Band of Misfits as...", gameModel.SupplyPiles.Where(p => p.GetCost() < gameModel.GetCost(this) && !p.CostsPotion && p.Count > 0 && p.Card.Is(CardType.Action)));
             if (pile != null)
             {
                 target = (CardModel)Activator.CreateInstance(pile.TopCard.GetType());
             }
         }
         if (target != null)
         {
             this.mimic = target;
             if (this.lockCount > 0)
             {
                 this.forceMimic = target;
             }
             this.SetMimic();
         }
     }
 }

 public override void PlayAttack(GameModel gameModel, IEnumerable<Player> attackedPlayers)
 {
     foreach (Player player in attackedPlayers)
     {
         player.GainCard(typeof(Curse));
     }
 }

        /// <summary>
        /// Generates the javascript code for the game described in the specified model.
        /// </summary>
        /// <param name="model">The model that describes the game.</param>
        public string GenerateGameCode(GameModel model)
        {
            if (model == null)
                throw new ArgumentNullException("model");

            Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;

            UpdateModules(model.Units);
            UpdateModules(model);

            var unitModules = new ModuleCollection();
            foreach (var unit in model.Units)
            {
                unitModules = new ModuleCollection(unitModules.Union(unit.Modules, Module.Comparer));
            }

            string background = model.Background.GenerateCode();
            string modules = unitModules.GenerateUnitModulesCode() + "\n" + model.Modules.GenerateGameModulesCode();
            string unitConstructors = GenerateUnitConstructors();
            string units = unitConstructors + model.Units.GenerateCollectionCode((unit) => unit.GenerateCode());
            string bindings = model.KeyBindings.GenerateCollectionCode((binding) => binding.GenerateCode());

            string game = Regex.Replace(gameTemplate, BackgroundPlaceholder, background, RegexOptions.None);
            game = Regex.Replace(game, ModulesPlaceholder, modules, RegexOptions.None);
            game = Regex.Replace(game, UnitsPlaceholder, units, RegexOptions.None);
            game = Regex.Replace(game, KeyBindingsPlaceholder, bindings, RegexOptions.None);

            return game;
        }

        public override void Play(GameModel gameModel)
        {
            List<CardModel> drawn = new List<CardModel>();
            List<CardModel> setAside = new List<CardModel>();
            do
            {
                CardModel card = gameModel.CurrentPlayer.DrawCard();
                if (card == null)
                {
                    break;
                }
                if (card.Is(CardType.Treasure))
                {
                    drawn.Add(card);
                }
                else
                {
                    setAside.Add(card);
                }
            } while (drawn.Count < 2);

            foreach(CardModel card in drawn)
            {
                gameModel.CurrentPlayer.PutInHand(card);
            }
            foreach (CardModel card in setAside)
            {
                gameModel.CurrentPlayer.DiscardCard(card);
            }
        }

        public override void Play(GameModel gameModel)
        {
            this.returnedCard = null;
            Player player = gameModel.CurrentPlayer;
            CardModel choice = player.Chooser.ChooseOneCard(CardChoiceType.Ambassador, "Choose a card to return to the supply", Chooser.ChoiceSource.FromHand, player.Hand);
            if (choice != null)
            {
                Pile supply = gameModel.SupplyPiles.Where(pile => pile.Card.Name == choice.Name).FirstOrDefault();
                if (supply != null)
                {
                    List<CardModel> toReturn = new List<CardModel>(player.Hand.Where(card => card.Name == choice.Name).Take(2));
                    this.returnedCard = choice.GetType();
                    string[] choices = new string[toReturn.Count + 1];
                    for (int i = 0; i < choices.Length; i++)
                    {
                        choices[i] = i.ToString();
                    }
                    int trashChoice = player.Chooser.ChooseOneEffect(EffectChoiceType.AmbassadorCount, choice, "Return how many to supply?", choices, choices);

                    for (int i = 0; i < trashChoice; i++)
                    {
                        player.RemoveFromHand(toReturn[i]);
                        supply.PutCardOnPile(toReturn[i]);
                    }
                }
            }
        }

 public override void Play(GameModel gameModel)
 {
     IEnumerable<int> c = gameModel.CurrentPlayer.Chooser.ChooseSeveralEffects(EffectChoiceType.TrustySteed, "Choose two:", 2, 2, choices, choiceDescriptions);
     foreach (int choice in c)
     {
         switch (choice)
         {
             case 0:
                 gameModel.CurrentPlayer.Draw();
                 gameModel.CurrentPlayer.Draw();
                 break;
             case 1:
                 gameModel.CurrentPlayer.AddActionCoin(2);
                 break;
             case 2:
                 gameModel.CurrentPlayer.GainActions(2);
                 break;
             case 3:
                 for (int i = 0; i < 4; i++)
                 {
                     gameModel.CurrentPlayer.GainCard(typeof(Silver));
                 }
                 gameModel.CurrentPlayer.PutDeckInDiscard();
                 break;
         }
     }
 }

        public GameModel GameById(int id)
        {
            GameModel ret = new GameModel();

            using (ADayInTheLifeEntities db = new ADayInTheLifeEntities())
            {
                try
                {
                    Game game = db.Games.Where(o => o.GameId == id).FirstOrDefault();

                    if (game == null)
                    {
                        throw new Exception(String.Format("Issue: Game {0} cannot be found", id));
                    }

                    ret = new GameModel()
                    {
                        GameId = game.GameId,
                        Players = game.Players,
                        WinCondition1 = game.WinCondition1,
                        WinCondition2 = game.WinCondition2,
                        WinCondition3 = game.WinCondition3,
                        WinCondition4 = game.WinCondition4
                    };
                }
                catch (Exception e)
                {
                    //TODO: Log This.
                }
            }
            return ret;
        }

 public override void PlayAttack(GameModel gameModel, IEnumerable<Player> attackedPlayers)
 {
     foreach(Player player in attackedPlayers)
     {
         player.HasMinusOneCoinToken = true;
     }
 }

 public override void Play(GameModel gameModel)
 {
     CardModel namedCard = gameModel.CurrentPlayer.Chooser.ChooseOneCard(CardChoiceType.NameACardForJourneyman, "Name a card", ChoiceSource.None, gameModel.AllCardsInGame);
     List<CardModel> match = new List<CardModel>();
     List<CardModel> nonMatch = new List<CardModel>();
     CardModel card = gameModel.CurrentPlayer.DrawCard();
     while (card != null)
     {
         if (card.Name == namedCard.Name)
         {
             match.Add(card);
         }
         else
         {
             nonMatch.Add(card);
             if(nonMatch.Count == 3)
             {
                 break;
             }
         }
         card = gameModel.CurrentPlayer.DrawCard();
     }
     foreach (CardModel nonMatched in nonMatch)
     {
         gameModel.CurrentPlayer.PutInHand(nonMatched);
     }
     foreach (CardModel matched in match)
     {
         gameModel.CurrentPlayer.DiscardCard(matched);
     }
 }

 public override void Play(GameModel gameModel)
 {
     if (!gameModel.CardModifiers.Any(modifier => modifier.GetType() == typeof(PrincessCardModifier)))
     {
         gameModel.AddCardModifier(new PrincessCardModifier());
     }
 }

 public override void PlayAttack(GameModel gameModel, IEnumerable<Player> attackedPlayers)
 {
     foreach (Player player in attackedPlayers)
     {
         player.DiscardTo(4);
     }
 }

        public async Task<IHttpActionResult> PutGameModel(int id, GameModel gameModel)
        {
            if (!ModelState.IsValid)
            {
                return BadRequest(ModelState);
            }

            if (id != gameModel.Id)
            {
                return BadRequest();
            }

            db.Entry(gameModel).State = EntityState.Modified;

            try
            {
                await db.SaveChangesAsync();
            }
            catch (DbUpdateConcurrencyException)
            {
                if (!GameModelExists(id))
                {
                    return NotFound();
                }
                else
                {
                    throw;
                }
            }

            return StatusCode(HttpStatusCode.NoContent);
        }

        public GameRoom(Dictionary<IClientHolder, string> inputClients)
        {
            gameModel = new GameModel(logger);

            foreach(var client in inputClients)
            {
                client.Key.OnGetMessageFromClient += OnGetMessageFromClient;
                clients.Add(client.Key);
                clientNames.Add(client.Value);
            }

            gameContext.StartKyoku += StartKyoku;
            gameContext.Tsumo += Tsumo;
            gameContext.Dahai += Dahai;
            gameContext.Chi += Chi;
            gameContext.Pon += Pon;
            gameContext.Kakan += Kakan;
            gameContext.Daiminkan += Daiminkan;
            gameContext.Ankan += Ankan;
            gameContext.OpenDora += OpenDora;
            gameContext.Rinshan += Rinshan;
            gameContext.Reach += Reach;
            gameContext.ReachDahai += ReachDahai;
            gameContext.ReachAccept += ReachAccept;
            gameContext.Hora += Hora;
            gameContext.Ryukyoku += Ryukyoku;
            gameContext.Endkyoku += EndKyoku;
            gameContext.EndGame += EndGame;
            gameContext.CheckIsRyuKyoku += CheckIsRyukyoku;
            gameContext.CheckIsEndGame += CheckIsEndGame;
        }