예제 #1
0
 public WerewolfGame()
 {
     using (WerewolfContext _db = new WerewolfContext())
     {
         try
         {
             if (!_roleInitialized)
             {
                 InitRoles();
             }
             if (!_actionInitialized)
             {
                 InitActions();
             }
             //FIXME, should move to database init part
         }
         catch (Exception ex)
         {
             Console.Out.WriteLine(ex.ToString());
         }
     }
     if (observers == null)
     {
         observers = new List <IObserver <WerewolfEvent> >();
     }
 }
예제 #2
0
 public List <Game> GetGames()
 {
     using (WerewolfContext _db = new WerewolfContext())
     {
         return(DeepClone <List <Game> >(_db.Games.Include(game => game.Players).ToList()));
     }
 }
예제 #3
0
 public List <Action> GetActions()
 {
     using (WerewolfContext _db = new WerewolfContext())
     {
         return(DeepClone <List <Action> >(_db.Actions.Include(ar => ar.ActionRoles).ThenInclude(r => r.Role).ToList()));
     }
 }
예제 #4
0
        public bool IsPlayerDead(string id)
        {
            var deadReasonArray = new[]
            {
                Player.StatusEnum.VoteDeadEnum,
                Player.StatusEnum.ShotDeadEnum,
                Player.StatusEnum.JailDeadEnum,
                Player.StatusEnum.HolyDeadEnum,
                Player.StatusEnum.KillDeadEnum,
            };
            long lid = Int64.Parse(id);

            using (WerewolfContext _db = new WerewolfContext())
            {
                Player player = _db.Players.Where(_p => _p.Id == lid).ToList()[0];
                foreach (Player.StatusEnum reason in deadReasonArray)
                {
                    if (player.Status == reason)
                    {
                        return(true);
                    }
                }
                return(false);
            }
        }
예제 #5
0
 public Player GetPlayerByName(string name)
 {
     using (WerewolfContext _db = new WerewolfContext())
     {
         return(DeepClone <Player>(_db.Players.Where(player => player.Name.ToUpper() == name.ToUpper()).ToList()[0]));
     }
 }
예제 #6
0
 public List <Player> GetPlayers()
 {
     using (WerewolfContext _db = new WerewolfContext())
     {
         return(DeepClone <List <Player> >(_db.Players.ToList()));
     }
 }
예제 #7
0
 public Game JoinGame(Game g, Player p)
 {
     using (WerewolfContext _db = new WerewolfContext())
     {
         Game game = _db.Games.Where(_g => _g.Id == g.Id).Include(_game => _game.Players).ToList()[0];
         if (game.Status != Game.StatusEnum.WaitingEnum)
         {
             throw new Exception("Game is already ended or running");
         }
         List <Player> players = game.Players.ToList();
         if (players.Count >= MAX_PLAYERS)
         {
             throw new Exception("Game is fulled already");
         }
         Player player = _db.Players.Where(_p => _p.Id == p.Id).ToList()[0];
         if (players.Contains(player))
         {
             throw new Exception("User in game already");
         }
         //player.Game = game.GameId.ToString();
         player.Status = Player.StatusEnum.AliveEnum;
         players.Add(player);
         game.Players = players;
         _db.Games.Update(game);
         _db.Players.Update(player);
         _db.SaveChanges();
         NotifyObserver(WerewolfEvent.PLAYER_JOIN, game.Id);
         return(DeepClone <Game>(game));
     }
 }
예제 #8
0
 private Action GetActionByName(string name)
 {
     using (WerewolfContext _db = new WerewolfContext())
     {
         return(DeepClone <Action>(_db.Actions.Where(action => action.Name == name).ToList()[0]));
     }
 }
예제 #9
0
 public List <Role> GetRoles()
 {
     using (WerewolfContext _db = new WerewolfContext())
     {
         return(DeepClone <List <Role> >(_db.Roles.Include(ar => ar.ActionRoles).ThenInclude(a => a.Action).ToList()));
     }
 }
예제 #10
0
 public Role GetRoleByName(string name)
 {
     using (WerewolfContext _db = new WerewolfContext())
     {
         return(DeepClone <Role>(_db.Roles.Where(role => role.Name == name).ToList()[0]));
     }
 }
예제 #11
0
        public void StartGame(string id)
        {
            Game game = null;

            using (WerewolfContext _db = new WerewolfContext())
            {
                long lid = Int64.Parse(id);
                game = _db.Games.Where(g => g.Id == lid).ToList()[0];
                if (game != null)
                {
                    game.Status = Game.StatusEnum.PlayingEnum;
                    game.ResetDayVoteList();
                    game.ResetNightVoteList();
                }
                else
                {
                    throw new Exception();
                }
                _db.Games.Update(game);
                _db.SaveChanges();
            }
            if (game != null)
            {
                NotifyObserver(WerewolfEvent.GAME_STARTED, game.Id);
            }
        }
예제 #12
0
 public void AddPlayer(Player player)
 {
     using (WerewolfContext _db = new WerewolfContext())
     {
         _db.Players.Add(player);
         _db.SaveChanges();
     }
 }
예제 #13
0
        public Player GetPlayer(string id)
        {
            long lid = Int64.Parse(id);

            using (WerewolfContext _db = new WerewolfContext())
            {
                return(DeepClone <Player>(_db.Players.Where(player => player.Id == lid).Include(player => player.Role).ToList()[0]));
            }
        }
예제 #14
0
        public Game GetGame(string id)
        {
            long lid = Int64.Parse(id);

            using (WerewolfContext _db = new WerewolfContext())
            {
                return(DeepClone <Game>(_db.Games.Include(game => game.Players).ThenInclude(player => player.Role).Where(game => game.Id == lid).ToList()[0]));
            }
        }
예제 #15
0
        public List <Player> GetPlayerByGame(string gameid)
        {
            long gid = Int64.Parse(gameid);

            using (WerewolfContext _db = new WerewolfContext())
            {
                Game _game = _db.Games.Where(game => game.Id == gid).Include(game => game.Players).ToList()[0];
                return(DeepClone <List <Player> >(_game.Players.ToList()));
            }
        }
예제 #16
0
        public Action GetAction(string id)
        {
            // Throws exception
            long lid = Int64.Parse(id);

            using (WerewolfContext _db = new WerewolfContext())
            {
                return(DeepClone <Action>(_db.Actions.Where(action => action.Id == lid).Include(ar => ar.ActionRoles).ThenInclude(r => r.Role).ToList()[0]));
            }
        }
예제 #17
0
        public Role GetRole(string id)
        {
            // Throws exception
            long lid = Int64.Parse(id);

            using (WerewolfContext _db = new WerewolfContext())
            {
                return(DeepClone <Role>(_db.Roles.Where(role => role.Id == lid).Include(ar => ar.ActionRoles).ThenInclude(a => a.Action).ToList()[0]));
            }
        }
예제 #18
0
 public Boolean IsPlayerExists(string name)
 {
     using (WerewolfContext _db = new WerewolfContext())
     {
         if (_db.Players.Where(player => player.Name.ToUpper() == name.ToUpper()).Count() > 0)
         {
             return(true);
         }
         return(false);
     }
 }
예제 #19
0
        public void SetGameDay(string id, int day)
        {
            long lid = Int64.Parse(id);

            using (WerewolfContext _db = new WerewolfContext())
            {
                Game game = _db.Games.Where(g => g.Id == lid).ToList()[0];
                game.Day = day;
                _db.Games.Update(game);
                _db.SaveChanges();
            }
        }
예제 #20
0
        public void SetPlayerStatus(string id, Player.StatusEnum status)
        {
            long lid = Int64.Parse(id);

            using (WerewolfContext _db = new WerewolfContext())
            {
                Player player = _db.Players.Where(p => p.Id == lid).ToList()[0];
                player.Status = status;
                _db.Players.Update(player);
                _db.SaveChanges();
            }
        }
예제 #21
0
        public void SetGameStatus(string id, Game.StatusEnum s)
        {
            long lid = Int64.Parse(id);

            using (WerewolfContext _db = new WerewolfContext())
            {
                Game game = _db.Games.Where(g => g.Id == lid).ToList()[0];
                game.Status = s;
                _db.Games.Update(game);
                _db.SaveChanges();
            }
        }
예제 #22
0
        public Game CreateGame()
        {
            Game game = new Game();

            game.Hash   = Guid.NewGuid().ToString();
            game.Status = Game.StatusEnum.WaitingEnum;
            //game.Players = new List<Player>();
            game.Period = Game.PeriodEnum.ProcessingEnum;
            using (WerewolfContext _db = new WerewolfContext())
            {
                _db.Games.Add(game);
                _db.SaveChanges();
                NotifyObserver(WerewolfEvent.GAME_CREATED, game.Id);
                return(DeepClone <Game>(_db.Games.OrderBy(g => g.Id).Last()));
            }
        }
예제 #23
0
 public Game LeaveGame(Game g, Player p)
 {
     using (WerewolfContext _db = new WerewolfContext())
     {
         Game          game    = _db.Games.Where(_g => _g.Id == g.Id).ToList()[0];
         List <Player> players = game.Players.ToList();
         Player        player  = _db.Players.Where(_p => _p.Id == p.Id).ToList()[0];
         players.Remove(player);
         player.Status = Player.StatusEnum.NotInGameEnum;
         game.Players  = players;
         _db.Games.Update(game);
         _db.Players.Update(player);
         _db.SaveChanges();
         return(DeepClone <Game>(game));
     }
 }
예제 #24
0
        public void ResetGameState(string id)
        {
            long lid = long.Parse(id);

            using (WerewolfContext _db = new WerewolfContext())
            {
                Game game = _db.Games.Where(g => g.Id == lid).ToList()[0];
                game.KillBySerialKiller   = null;
                game.HealedByDoctor       = null;
                game.Jailed               = null;
                game.ProtectedByBodyguard = null;
                game.ResetNightVoteList();
                game.ResetDayVoteList();
                _db.Games.Update(game);
                _db.SaveChanges();
            }
        }
예제 #25
0
        public void DeletePlayer(string id)
        {
            long lid = Int64.Parse(id);

            using (WerewolfContext _db = new WerewolfContext())
            {
                Player player = _db.Players.Where(p => p.Id == lid).ToList()[0];
                if (player != null)
                {
                    _db.Players.Remove(player);
                }
                else
                {
                    throw new Exception();
                }
                _db.SaveChanges();
            }
        }
예제 #26
0
        public List <Action> GetActionByRoleId(string id)
        {
            long lid = Int64.Parse(id);

            //return DeepClone<List<Action>>(_db.Actions.Where(action => action.Roles.Any(role => role.RoleId == lid)).ToList());
            using (WerewolfContext _db = new WerewolfContext())
            {
                Role          role    = _db.Roles.Where(r => r.Id == lid).Include(ar => ar.ActionRoles).ThenInclude(a => a.Action).ToList()[0];
                List <Action> actions = new List <Action>();
                foreach (ActionRole ar in role.ActionRoles)
                {
                    // ar.Action.ActionRoles = null;
                    // ar.Action.Roles = null;
                    actions.Add(ar.Action);
                }
                return(actions);
            }
            //return DeepClone<List<Action>>(role.Actions.ToList());
            //return DeepClone<List<Action>>(_db.Roles.Where(r => r.Id == lid).Include(ar => ar.ActionRoles).ThenInclude(a => a.Action).ToList()[0].Actions.ToList());
        }
예제 #27
0
 public void UpdatePlayer(Player player)
 {
     using (WerewolfContext _db = new WerewolfContext())
     {
         Player p = _db.Players.Where(pr => pr.Id == player.Id).ToList()[0];
         if (p == null)
         {
             throw new Exception("User not found");
         }
         if (p.Name != player.Name)
         {
             throw new Exception("Not allow to change name");
         }
         if (p != null)
         {
             p.Password = player.Password;
             p.Session  = player.Session;
             p.GameId   = player.GameId;
             if (p.GameId == null)
             {
                 p.Game = null;
             }
             else
             {
                 p.Game = _db.Games.Where(g => g.Id == player.GameId).ToList()[0];
             }
             if (player.Role != null)
             {
                 p.Role = _db.Roles.Where(r => r.Id == player.Role.Id).ToList()[0];
             }
             _db.Players.Update(p);
             _db.SaveChanges();
         }
         else
         {
             throw new Exception("Player not found");
         }
     }
 }
예제 #28
0
        public Player GetPlayerBySession(string session)
        {
            List <Player> players = null;

            using (WerewolfContext _db = new WerewolfContext())
            {
                //return DeepClone<Player>(_db.Players.Where(player => player.Session == session).Include(player => player.Game).ThenInclude(game => game.Players).ThenInclude(p => p.Role).ThenInclude(r => r.ActionRoles).ToList()[0]);
                try
                {
                    players = _db.Players.Where(player => player.Session == session).Include(player => player.Game).ThenInclude(game => game.Players).ThenInclude(p => p.Role).ThenInclude(r => r.ActionRoles).ToList();
                }
                catch (Exception ex)
                {
                    throw ex;
                }
            }
            if (players != null && players.Count > 0)
            {
                return(DeepClone <Player>(players[0]));
            }
            return(null);
        }
예제 #29
0
        public void DeleteGame(string id)
        {
            long lid  = Int64.Parse(id);
            Game game = null;

            using (WerewolfContext _db = new WerewolfContext())
            {
                game = _db.Games.Where(g => g.Id == lid).ToList()[0];
                if (game != null)
                {
                    _db.Games.Remove(game);
                }
                else
                {
                    throw new Exception();
                }
                _db.SaveChanges();
            }
            if (game != null)
            {
                NotifyObserver(WerewolfEvent.GAME_DELETED, game.Id);
            }
        }
예제 #30
0
        public OutcomeEnum PostAction(string sessionID, string actionID, string targetID)
        {
            Game   game;
            Player player;
            Player target;

            DNWS.Werewolf.Action action;
            Role role;

            try
            {
                player = GetPlayerBySession(sessionID);
            }
            catch (Exception)
            {
                throw new Exception("Player not found.");
            }
            if (player.Status != Player.StatusEnum.AliveEnum)
            {
                throw new Exception("Player is not alived.");
            }
            try
            {
                action = GetAction(actionID);
            }
            catch (Exception)
            {
                throw new Exception("Action not found.");
            }
            try
            {
                target = GetPlayer(targetID);
            }
            catch (Exception)
            {
                throw new Exception("Target not found.");
            }
            if (target.Id == player.Id)
            {
                throw new Exception("You can't perform on yourself.");
            }
            game = GetGame(player.Game.Id.ToString());
            if (game == null)
            {
                throw new Exception("Player is not in a game.");
            }
            if (game.Period == Game.PeriodEnum.ProcessingEnum)
            {
                throw new Exception("Please wait for processing.");
            }
            role = GetRole(player.Role.Id.ToString());

            if (role == null)
            {
                throw new Exception("Player does not have any role.");
            }
            List <int> action_ids = role.ActionRoles.Select(ar => ar.Action.Id).ToList();

            //if (!role.Actions.Contains(action))
            if (!action_ids.Contains(action.Id))
            {
                throw new Exception("Player's role does not have this action.");
            }
            if (game.Status != Game.StatusEnum.PlayingEnum)
            {
                throw new Exception("Game is not playable.");
            }
            if (game.Period == Game.PeriodEnum.DayEnum)
            {
                if (target.Status != Player.StatusEnum.AliveEnum)
                {
                    return(OutcomeEnum.TargetIsNotAlivedEnum);
                }
                if (action.Name == WerewolfGame.ACTION_DAY_VOTE)
                {
                    if (game.DayVoteList.ContainsKey(player.Id) && game.DayVoteList[player.Id] == target.Id)
                    {
                        game.DayVoteList.Remove(player.Id);
                    }
                    else
                    {
                        game.DayVoteList[player.Id] = target.Id;
                    }
                    using (WerewolfContext _db = new WerewolfContext())
                    {
                        _db.Games.Update(game);
                        _db.SaveChanges();
                    }
                    return(OutcomeEnum.ActionPerformedEnum);
                }
                else if (action.Name == WerewolfGame.ACTION_ENCHANT)
                {
                    if (game.Enchanted == target)
                    {
                        game.Enchanted = null;
                    }
                    else
                    {
                        game.Enchanted = target;
                    }
                    return(OutcomeEnum.ActionPerformedEnum);
                }
                else if (action.Name == WerewolfGame.ACTION_JAIL)
                {
                    if (game.Jailed == target)
                    {
                        game.Jailed = null;
                    }
                    else
                    {
                        game.Jailed = target;
                    }
                    return(OutcomeEnum.ActionPerformedEnum);
                }
                else if (action.Name == WerewolfGame.ACTION_SHOOT)
                {
                    SetPlayerStatus(target.Id.ToString(), Player.StatusEnum.ShotDeadEnum);
                    return(OutcomeEnum.TargetDeadEnum);
                }
                else if (action.Name == WerewolfGame.ACTION_HOLYWATER)
                {
                    if ((new[] { WerewolfGame.ROLE_WEREWOLF,
                                 WerewolfGame.ROLE_ALPHA_WEREWOLF,
                                 WerewolfGame.ROLE_WEREWOLF_SEER,
                                 WerewolfGame.ROLE_WEREWOLF_SHAMAN }).Contains(target.Role.Name))
                    {
                        SetPlayerStatus(target.Id.ToString(), Player.StatusEnum.HolyDeadEnum);
                        return(OutcomeEnum.TargetDeadEnum);
                    }
                    else
                    {
                        SetPlayerStatus(player.Id.ToString(), Player.StatusEnum.HolyDeadEnum);
                        return(OutcomeEnum.PlayerDeadEnum);
                    }
                }
            }
            else if (game.Period == Game.PeriodEnum.NightEnum)
            {
                if (game.Jailed != null && player.Id == game.Jailed.Id)
                {
                    return(OutcomeEnum.ActionPerformedEnum);
                }
                if (action.Name == WerewolfGame.ACTION_REVIVE)
                {
                    if (IsPlayerDead(target.Id.ToString()))
                    {
                        throw new Exception("Target is not dead.");
                    }
                    if (game.ReviveByMedium == target)
                    {
                        game.ReviveByMedium = null;
                    }
                    else
                    {
                        game.ReviveByMedium = target;
                    }
                    return(OutcomeEnum.ActionPerformedEnum);
                }
                if (target.Status != Player.StatusEnum.AliveEnum)
                {
                    throw new Exception("Target is not alived.");
                }
                if (action.Name == WerewolfGame.ACTION_NIGHT_VOTE)
                {
                    if (game.NightVoteList.ContainsKey(player.Id) && game.NightVoteList[player.Id] == target.Id)
                    {
                        game.NightVoteList.Remove(player.Id);
                    }
                    else
                    {
                        game.NightVoteList[player.Id] = target.Id;
                    }
                    using (WerewolfContext _db = new WerewolfContext())
                    {
                        _db.Games.Update(game);
                        _db.SaveChanges();
                    }
                    return(OutcomeEnum.ActionPerformedEnum);
                }
                else if (action.Name == WerewolfGame.ACTION_GUARD)
                {
                    if (game.ProtectedByBodyguard == target)
                    {
                        game.ProtectedByBodyguard = null;
                    }
                    else
                    {
                        game.ProtectedByBodyguard = target;
                    }
                    using (WerewolfContext _db = new WerewolfContext())
                    {
                        _db.Games.Update(game);
                        _db.SaveChanges();
                    }
                    return(OutcomeEnum.ActionPerformedEnum);
                }
                else if (action.Name == WerewolfGame.ACTION_HEAL)
                {
                    if (game.HealedByDoctor == target)
                    {
                        game.HealedByDoctor = null;
                    }
                    else
                    {
                        game.HealedByDoctor = target;
                    }
                    using (WerewolfContext _db = new WerewolfContext())
                    {
                        _db.Games.Update(game);
                        _db.SaveChanges();
                    }
                    return(OutcomeEnum.ActionPerformedEnum);
                }
                else if (action.Name == WerewolfGame.ACTION_KILL)
                {
                    if (game.KillBySerialKiller == target)
                    {
                        game.KillBySerialKiller = null;
                    }
                    else
                    {
                        game.KillBySerialKiller = target;
                    }
                    using (WerewolfContext _db = new WerewolfContext())
                    {
                        _db.Games.Update(game);
                        _db.SaveChanges();
                    }
                    return(OutcomeEnum.ActionPerformedEnum);
                }
                else if (action.Name == WerewolfGame.ACTION_REVEAL)
                {
                    if (target == game.Enchanted)
                    {
                        return(OutcomeEnum.EnchantedEnum);
                    }
                    return(OutcomeEnum.RevealedEnum);
                }
                else if (action.Name == WerewolfGame.ACTION_AURA)
                {
                    if (new[] {
                        WerewolfGame.ROLE_GUNNER,
                        WerewolfGame.ROLE_JAILER,
                        WerewolfGame.ROLE_MEDIUM,
                        WerewolfGame.ROLE_ALPHA_WEREWOLF,
                        WerewolfGame.ROLE_HEAD_HUNTER,
                        WerewolfGame.ROLE_SERIAL_KILLER
                    }.Contains(target.Name))
                    {
                        return(OutcomeEnum.UnknownEnum);
                    }
                    else if (new[] {
                        WerewolfGame.ROLE_WEREWOLF,
                        WerewolfGame.ROLE_WEREWOLF_SEER,
                        WerewolfGame.ROLE_WEREWOLF_SHAMAN
                    }.Contains(target.Name))
                    {
                        return(OutcomeEnum.WerewolfEnum);
                    }
                    return(OutcomeEnum.VillagerEnum);
                }
            }
            return(OutcomeEnum.NotValidActionEnum);
        }