Exemplo n.º 1
0
        List <RummyTile> Analise(List <RummyTile> list)
        {
            List <List <RummyTile> > possibleMoveList = new List <List <RummyTile> >();
            var colorGroups = from rum in list
                              orderby rum.Number
                              group rum by rum.Color into ColorGroup
                              select ColorGroup;

            colorGroups = colorGroups.OrderBy(x => x.Key);
            var isHasOkeyStones = list.Where(x => (x.RummyTileSpecialId == -1) || (x.RummyTileSpecialId == -2)).ToList();

            foreach (var item in colorGroups)
            {
                var sameColorList          = item.ToList();
                List <RummyTile> canUsable = new List <RummyTile>();
                var ifHasOkeyStones        = list.Where(x => (x.RummyTileSpecialId == -1) || (x.RummyTileSpecialId == -2)).ToList();
                int hasOkeyStonesCount     = ifHasOkeyStones.Count;
                int usedOkeyStonesCounter  = 0;
                for (int i = 0; i < sameColorList.Count; i++)
                {
                    if ((i + 1) == sameColorList.Count)
                    {
                        if (canUsable.Count >= 3)
                        {
                            possibleMoveList.Add(canUsable);
                        }
                        else if (canUsable.Count == 2 && hasOkeyStonesCount > usedOkeyStonesCounter)
                        {
                            canUsable.Add(ifHasOkeyStones[0]);
                            possibleMoveList.Add(canUsable);
                        }
                        canUsable = new List <RummyTile>();
                        break;
                    }
                    if (sameColorList[i].Number + 1 == sameColorList[i + 1].Number)
                    {
                        if (!CheckItemIsInList(canUsable, sameColorList[i]))
                        {
                            if (ifHasOkeyStones.Count != 0 && hasOkeyStonesCount > usedOkeyStonesCounter)
                            {
                                if (sameColorList[i].Color == ifHasOkeyStones[0].Color &&
                                    sameColorList[i].Number == ifHasOkeyStones[0].Number)
                                {
                                    canUsable.Add(sameColorList[i]);
                                    usedOkeyStonesCounter++;
                                }
                                else if (sameColorList[i] != ifHasOkeyStones[0])
                                {
                                    canUsable.Add(sameColorList[i]);
                                }
                            }
                            else
                            {
                                if (ifHasOkeyStones.Count != 0 &&
                                    sameColorList[i].Color != ifHasOkeyStones[0].Color &&
                                    sameColorList[i].Number != ifHasOkeyStones[0].Number)
                                {
                                    canUsable.Add(sameColorList[i]);
                                }
                                else if (ifHasOkeyStones.Count == 0)
                                {
                                    canUsable.Add(sameColorList[i]);
                                }
                            }
                        }
                        if (!CheckItemIsInList(canUsable, sameColorList[i + 1]))
                        {
                            if (ifHasOkeyStones.Count != 0 && hasOkeyStonesCount > usedOkeyStonesCounter)
                            {
                                if (sameColorList[i + 1].Color == ifHasOkeyStones[0].Color &&
                                    sameColorList[i + 1].Number == ifHasOkeyStones[0].Number)
                                {
                                    canUsable.Add(sameColorList[i + 1]);
                                    usedOkeyStonesCounter++;
                                }
                                else if (sameColorList[i + 1] != ifHasOkeyStones[0])
                                {
                                    canUsable.Add(sameColorList[i + 1]);
                                }
                            }
                            else
                            {
                                if (ifHasOkeyStones.Count != 0 &&
                                    sameColorList[i + 1].Color != ifHasOkeyStones[0].Color &&
                                    sameColorList[i + 1].Number != ifHasOkeyStones[0].Number)
                                {
                                    canUsable.Add(sameColorList[i + 1]);
                                }
                                else if (ifHasOkeyStones.Count == 0)
                                {
                                    canUsable.Add(sameColorList[i + 1]);
                                }
                            }
                        }
                    }
                    else if (sameColorList[i].Number + 2 == sameColorList[i + 1].Number &&
                             ifHasOkeyStones.Count != 0 &&
                             ifHasOkeyStones[0] != sameColorList[i] &&
                             ifHasOkeyStones[0] != sameColorList[i + 1] &&
                             hasOkeyStonesCount > usedOkeyStonesCounter
                             )
                    {
                        if (!CheckItemIsInList(canUsable, sameColorList[i]))
                        {
                            canUsable.Add(sameColorList[i]);
                        }
                        if (!CheckItemIsInList(canUsable, ifHasOkeyStones[0]))
                        {
                            canUsable.Add(ifHasOkeyStones[0]);
                            usedOkeyStonesCounter++;
                        }
                        if (!CheckItemIsInList(canUsable, sameColorList[i + 1]))
                        {
                            canUsable.Add(sameColorList[i + 1]);
                        }
                    }
                    else
                    {
                        if (canUsable.Count >= 3)
                        {
                            possibleMoveList.Add(canUsable);
                        }
                        canUsable = new List <RummyTile>();
                    }
                }
            }

            //renklere göre sıralı olanları aldıktan sonra aynı numaralı farklı renkte olan grupları almak istiyoruz
            //ancak önce elimizdeki okeyi burada iyi kullanabilirmiyiz kontrol edelim

            var maxItemInUsableList = new List <RummyTile>();

            if (possibleMoveList.Count() != 0)
            {
                maxItemInUsableList = possibleMoveList.OrderByDescending(x => x.Count()).First();
            }
            //Eğer kullanılması muhtemel hamleler listemizde 4 lü veya 5 li perler varsa diğer duruma hiç bakılmaz
            if (maxItemInUsableList.Count < 4 && isHasOkeyStones.Count != 0)
            {
                int groupMemberCount = 1;
                if (maxItemInUsableList.Count > 1)
                {
                    groupMemberCount = maxItemInUsableList.Count;
                }

                var numberGroup = from rum in list
                                  orderby rum.Number
                                  group rum by rum.Number
                                  into NumberGroup
                                  select NumberGroup;
                var isThereFourtPerWithoutOkey = false;
                var maxGroup = numberGroup.OrderByDescending(x => x.Count());
                foreach (var item in maxGroup)
                {
                    var subList        = item.ToList();
                    var rummyTile      = subList[0];
                    var usingTempTiles = new List <RummyTile>();
                    usingTempTiles.Add(rummyTile);
                    for (int i = 1; i < subList.Count; i++)
                    {
                        var query = usingTempTiles.Where(x => x.Color == subList[i].Color).ToList();
                        if (query.Count == 0)
                        {
                            usingTempTiles.Add(subList[i]);
                        }
                    }
                    if (usingTempTiles.Count == 3)
                    {
                        usingTempTiles.Add(isHasOkeyStones[0]);
                        possibleMoveList.Add(usingTempTiles);
                    }
                    else if (usingTempTiles.Count > 3)
                    {
                        isThereFourtPerWithoutOkey = true;
                        list           = DeleteFromList(list, usingTempTiles);
                        usingTempTiles = new List <RummyTile>();

                        /*
                         * eğer okey kullanmadan 4 lü per yapabiliyorsak perleri listeden çıkartıp tekrar aynı fonksiyonu çağırırız.
                         */
                    }
                }
                if (isThereFourtPerWithoutOkey)
                {
                    list = Analise(list);
                }
            }

            var haveMaxItemList = new List <RummyTile>();

            if (possibleMoveList.Count() != 0 && isHasOkeyStones.Count() > 0)
            {
                haveMaxItemList = possibleMoveList.OrderByDescending(x => x.Count()).First();
                list            = DeleteFromList(list, haveMaxItemList);
            }
            else if (possibleMoveList.Count() != 0 && isHasOkeyStones.Count() == 0)
            {
                foreach (var item in possibleMoveList)
                {
                    list = DeleteFromList(list, item);
                }
            }



            var numberGroup2 = from rum in list
                               orderby rum.Number
                               group rum by rum.Number
                               into NumberGroup
                               where NumberGroup.Count() > 2
                               select NumberGroup;

            var usingTiles = new List <RummyTile>();

            foreach (var item in numberGroup2)
            {
                var subList        = item.ToList();
                var rummyTile      = subList[0];
                var usingTempTiles = new List <RummyTile>();
                usingTempTiles.Add(rummyTile);
                for (int i = 1; i < subList.Count; i++)
                {
                    var query = usingTempTiles.Where(x => x.Color == subList[i].Color).ToList();
                    if (query.Count == 0)
                    {
                        usingTempTiles.Add(subList[i]);
                    }
                }
                if (usingTempTiles.Count >= 3)
                {
                    usingTiles.AddRange(usingTempTiles);
                }
            }
            list = DeleteFromList(list, usingTiles);
            return(list);
        }
Exemplo n.º 2
0
 protected bool Equals(NumberGroup other)
 {
     return(Value == other.Value && Count == other.Count);
 }