business.cs

经典游戏程序设计：visual c++ 上的杀人游戏源代码

                                    && v.RoundNo == vote.RoundNo
                                    && v.Voter == vote.Voter).Count() == 0)
                {
                    var updateActivity = db.Activities.Single(a => a.ActivityNo == activity.ActivityNo);
                    if (updateActivity.RoundCount != activity.RoundCount)
                    {
                        updateActivity.RoundCount = activity.RoundCount;
                    }

                    db.Votes.InsertOnSubmit(vote);
                    db.SubmitChanges();

                    if (IsEveryVote(activity))
                    {
                        List<PlayerEntity> playerEntities = GetTheMostCandidates(activity);

                        if (playerEntities.Count == 1)
                        {
                            KillPlayer(playerEntities[0], activity);
                        }

                        return playerEntities;
                    }
                }
            }

            return new List<PlayerEntity>();
        }

        private static List<string> GetCurrentVoters(Activity activity)
        {
            using (DataMappingDataContext db = new DataMappingDataContext(true))
            {
                var playerInGames = from pig in db.Players
                                    where pig.GameNo == activity.GameNo && pig.IsActive == (int)IsActiveFlag.Active
                                    select pig;

                List<String> userId = new List<string>();

                switch ((ActivityTypeFlag)activity.ActivityTypeID)
                {
                    case ActivityTypeFlag.Kill:
                        userId = playerInGames.Where(pig => pig.RoleID == (int)RoleFlag.Killer).Select(p => p.UserID).ToList();
                        break;
                    case ActivityTypeFlag.Investigate:
                        userId = playerInGames.Where(pig => pig.RoleID == (int)RoleFlag.Police).Select(p => p.UserID).ToList();
                        break;
                    default:
                        userId = playerInGames.Select(p => p.UserID).ToList();
                        break;
                }

                return userId;
            }
        }

        private static bool IsEveryVote(Activity activity)
        {
            List<string> voters = GetCurrentVoters(activity);

            if (voters == null || voters.Count == 0)
            {
                return false;
            }

            using (DataMappingDataContext db = new DataMappingDataContext(true))
            {
                List<string> realVoters = (from r in db.Votes
                                           where r.ActivityNo == activity.ActivityNo
                                                 && r.RoundNo == activity.RoundCount
                                           select r.Voter).ToList();

                foreach (var item in voters)
                {
                    if (!realVoters.Contains(item))
                    {
                        return false;
                    }
                }

                return true;
            }
        }

        private static void KillPlayer(PlayerEntity playerEntity, Activity activity)
        {
            using (DataMappingDataContext db = new DataMappingDataContext(true))
            {
                Player playerInGame = db.Players.Single(pig => pig.GameNo == playerEntity.GameNo && pig.UserID == playerEntity.UserID);
                playerInGame.IsActive = (int)IsActiveFlag.Dead;
                playerInGame.DeadActivityNo = activity.ActivityNo;

                db.SubmitChanges();
            }
        }

        private static List<PlayerEntity> GetTheMostCandidates(Activity activity)
        {

            using (DataMappingDataContext db = new DataMappingDataContext(true))
            {
                var voteResult = from vr in db.Votes
                          where vr.ActivityNo == activity.ActivityNo
                                && vr.RoundNo == activity.RoundCount
                          group vr by vr.Candidate into g
                                 orderby g.Count() descending
                          select new { Candidate = g.Key, VoteCount = g.Count() };

                var result = voteResult.ToList();

                if (result.Count == 0)
                {
                    throw new Exception("None vote!!!??");
                }

                List<string> mostCandidateIDs = (from r in result
                          where r.VoteCount == result[0].VoteCount
                          select r.Candidate).ToList();

                var most = (from p in db.Players
                        where p.GameNo == activity.GameNo
                            && mostCandidateIDs.Contains(p.UserID)
                        select p).ToList();
                
                List<PlayerEntity> playerEntities = new List<PlayerEntity>();

                for (int i = 0; i < most.Count; i++)
                {
                    var pEntity = new PlayerEntity();

                    pEntity.UserID = most[i].UserID;
                    pEntity.GameNo = most[i].GameNo;
                    pEntity.IsActive = most[i].IsActive;
                    pEntity.RoleID = most[i].RoleID;
                    pEntity.DeadActivityNo = most[i].DeadActivityNo;

                    pEntity.IP = db.Users.Single(p => p.UserID == most[i].UserID).IP;

                    playerEntities.Add(pEntity);
                }
                
                return playerEntities;
            }
        }
        #endregion


        public static Player GetPlayer(string userId, Game game)
        {
            using (DataMappingDataContext db = new DataMappingDataContext(true))
            {
                return db.Players.Where(c => c.UserID == userId && c.GameNo == game.GameNo).SingleOrDefault();
            }
        }

        public static IList<PlayerEntity> GetPlayerEntities(RoleFlag roleFlag, IsActiveFlag isAlive, Game game)
        {
            using (DataMappingDataContext db = new DataMappingDataContext(true))
            {
                List<int> role = new List<int>();
                if ((roleFlag & RoleFlag.Civilian) == RoleFlag.Civilian)
                {
                    role.Add((int)RoleFlag.Civilian);
                }
                if ((roleFlag & RoleFlag.Killer) == RoleFlag.Killer)
                {
                    role.Add((int)RoleFlag.Killer);
                }
                if ((roleFlag & RoleFlag.Police) == RoleFlag.Police)
                {
                    role.Add((int)RoleFlag.Police);
                }
                List<int> isActiveFlag = new List<int>();
                if ((isAlive & IsActiveFlag.Active) == IsActiveFlag.Active)
                {
                    isActiveFlag.Add((int)IsActiveFlag.Active);
                }
                if ((isAlive & IsActiveFlag.Dead) == IsActiveFlag.Dead)
                {
                    isActiveFlag.Add((int)IsActiveFlag.Dead);
                }
                var q = db.Players.WhereIn("RoleID", role)
                    .WhereIn("IsActive", isActiveFlag)
                    .Where(c=>c.GameNo == game.GameNo)
                    .Select(c => new PlayerEntity
                    {
                        UserID = c.UserID,
                        IsActive = c.IsActive,
                        RoleID = c.RoleID,
                        IP = c.User.IP
                    });
                return q.ToList();
            }
        }

        public static IList<User> GetUser(IsOnlineFlag isOnline)
        {
            using (DataMappingDataContext db = new DataMappingDataContext(true))
            { 
                List<int> online = new List<int>();
                if ((isOnline & IsOnlineFlag.Online) == IsOnlineFlag.Online)
                {
                    online.Add((int)IsOnlineFlag.Online);
                }
                if ((isOnline & IsOnlineFlag.Offline) == IsOnlineFlag.Offline)
                {
                    online.Add((int)IsOnlineFlag.Offline);
                }

                return db.Users.WhereIn("IsOnline", online).ToList();
            }
        }

        public static IQueryable<TSource> WhereIn<TSource, TIn>(this IQueryable<TSource> baseQuery, string propName, IEnumerable<TIn> propValues)
        {
            // Define what will be a parameter for the lambda expression.
            ParameterExpression param = Expression.Parameter(typeof(TSource), "p");

            // Define the equality check for each value, in a queue.
            Expression getTestID = Expression.Property(param, propName);
            Queue<Expression> nodes = new Queue<Expression>();
            foreach (TIn testId in propValues)
                nodes.Enqueue(Expression.Equal(getTestID, Expression.Constant(testId)));

            // Go through the queue combining the nodes with OR expressions, to form a balanced tree (to avoid stack overflow)
            while (nodes.Count > 1)
                nodes.Enqueue(Expression.Or(nodes.Dequeue(), nodes.Dequeue()));

            // Now complete the lambda expression and use it in a Where clause
            if (nodes.Count == 1)
                return baseQuery.Where((Expression<Func<TSource, bool>>)Expression.Lambda(nodes.Dequeue(), param));

            // Exception condition...
            return baseQuery.Where(p => false);
        }


        

    }
}