Ejemplo n.º 1
0
        public static void HandleNewStrategy(GlobalClass.StrategyType gcst, ref cSpinControl cSC, ref int FilterSize)
        {
            int i, n;

            switch (gcst)
            {
            case GlobalClass.StrategyType.RUN_JOINSUITS_INPLACE:
                foreach (board tb in cSC.ThisBoardSeries)
                {
                    board nb = tb;
                    Strategy.ExposeTop(ref nb);
                    Strategy.RunJoinables(ref nb, true);
                }
                break;

            case GlobalClass.StrategyType.SPIN_JOINSUITS:
                n = cSC.ThisBoardSeries.Count;
                for (i = 0; i < n; i++)
                {
                    board tb = cSC.ThisBoardSeries[i];
                    Strategy.FirstStrategy(ref tb);
                }
                break;

            case GlobalClass.StrategyType.REDUCE_SUITS:
                PerformReduceSuits(ref cSC, FilterSize);
                break;

            default:
                Debug.Assert(false);
                break;
            }
            ;
        }
Ejemplo n.º 2
0
        public int GetBoards(ref cSpinControl cSC)
        {
            int   i, j = 0;
            int   OriginalCount = NewBoards.Count;
            board nb;

            cSC.ThisBoardSeries.Clear();
            for (i = 0; i < NewBoards.Count; i++)
            {
                nb = NewBoards[i];
                //if (nb.NumEmptyColumns == 0 || i > OriginalCount)
                if (nb.bWasDealtTo)
                {
                    //bs.Suitable.PerformSuitability(ref nb, ref NewBoards);
                    //if (j == 0)
                    //{
                    //    bs.SetSuitableValues(nb.bIsCompletable);
                    //}
                    nb.ID = cSC.ThisBoardSeries.Count;
                    cSC.ThisBoardSeries.Add(nb);
                    j++;
                }
            }
            NewBoards.Clear();
            Console.WriteLine("Added " + j + " boards with this new deal");
            return(j);
        }
Ejemplo n.º 3
0
 public cDealStrategy(ref cSpinControl cSC)
 {
     NewBoards      = new List <board>();
     OEmpties       = new List <int>();
     StartOfDealPtr = 0;
     this.cSC       = cSC;
 }
Ejemplo n.º 4
0
 public cDisassemble(ref cSpinControl cSC)
 {
     this.cSC = cSC;
     runSEQdisassemble();
     runSOSdisassemble();
     CardCountMoves = new List <cCardCountMoves>();
 }
Ejemplo n.º 5
0
        public void AddShrinkCode(ref cSpinControl cSC, int cnt)
        {
            int n = TheseMoves.Count - 1;

            if (cnt > 99)
            {
                cnt = 99;
            }
            // jys oct 2012 remove  this???
            // nov 2012 Debug.Assert(n > 0);
            TheseMoves[n].ShrinkCode = utils.GetShrinkCode(ref cSC).ToString() + "-" + utils.Lpadto(cnt.ToString(), 2);
        }
Ejemplo n.º 6
0
        public static bool tbsCompareAll(ref cSpinControl cSC, int id1, int id2)
        {
            bool bSame1 = tbsCompare(ref cSC, id1, id2);
            bool bSame2 = cSC.stlookup.cstCompare(id1, id2);

            if (bSame1 && bSame2)
            {
                Console.WriteLine("ERROR:  Boards are identical! " + id1 + " " + id2);
                Console.WriteLine("        Unique IDs are: " + cSC.ThisBoardSeries[id1].UniqueID + " " + cSC.ThisBoardSeries[id2].UniqueID);
            }
            return(bSame1 && bSame2);
        }
Ejemplo n.º 7
0
 // save the DEALx which is the best of the DEALx_1, DEALx..12 etc and takes a while to identify
 // usually the FirstEmptyColumn deck is just as good to use and is calculated earlier
 private static void SaveBestBoard(ref cSpinControl cSC)
 {
     cSC.LocalDealCounter         = 0;
     cSC.BestBoard.DealCountIndex = cSC.LocalDealCounter;
     cSC.Deck.SaveBoardAtDeal(GlobalClass.eSBAD.eStartGather, ref cSC.BestBoard, 0);
     if (cSC.bSpinDidAllBoards && cSC.BestBoard.DealCounter == 5)
     {
         // if we ran that reduce suits here it would be nice 16nov2012               }
         GlobalClass.No_Cards_Left.Data.Add("MSG", "Out of Cards in HandleDeal");
         throw GlobalClass.No_Cards_Left;
     }
 }
Ejemplo n.º 8
0
        public static int PerformReduceSuits(ref cSpinControl cSC, int m)
        {
            bool bAny = true;
            int  cnt = 0;
            int  j, n, OCount = cSC.ThisBoardSeries.Count;

            for (int i = 0; i < OCount; i++)    // Reduce can add boards to this
            {
                board oldtb = cSC.ThisBoardSeries[i];
                board tb    = new board(ref oldtb);
                if (tb.bIsCompletable)
                {
                    Suitable.PerformSuitabilityScreening(ref tb);
                }
                else
                {
                    int Any = Strategy.TryUnstackOne(ref tb, ref cnt);
                    //Strategy.RunJoinables(ref tb, true);
                    if (Any == 0)
                    {
                        continue;
                    }
                    if (tb.bIsCompletable)
                    {
                        Suitable.PerformSuitabilityScreening(ref tb);
                    }
                    else
                    {
                        cSC.NextBoardSeries.Add(tb);   // it will not be processed because of bIsCompletable however, it
                    }                                  // will be moved back into ThisBoardSeries for another try at it
                }
            }
            bAny = (cSC.NextBoardSeries.Count > 0);
            return(cSC.NextBoardSeries.Count);  // jys 16nov2012

            Debug.Assert(bAny);
            while (bAny)
            {
                bAny = Reduce.RunFilter(m);
            }
            n = cSC.ThisBoardSeries.Count;
            if (OCount < n)
            {
                j = 0;
                for (int i = OCount; i < n; i++)
                {
                    cSC.ThisBoardSeries[j] = cSC.ThisBoardSeries[OCount + j];
                    j++;
                }
                cSC.ThisBoardSeries.RemoveRange(OCount, n - OCount);
            }
        }
Ejemplo n.º 9
0
        public cSpinAllMoves(ref cSpinControl cSC)
        {
//            Suitable = new csuitable(ref MaxValues);

            cSC.stlookup     = new Cstlookup(cSC.MaxValues.MaxInsertsWhenSuiting * 4);
            cSC.PrevSeed     = new cSeed();
            cSC.ThisSeed     = new cSeed();
            cSC.SortedScores = new List <cBestScore>(128);
            this.cSC         = cSC;
            NumSuitsWritten  = 0;
            SuitsCompleted   = new int[4];
            ClearSeries();
            RepeatDepth = 0;
            strSpinType = "";
        }
Ejemplo n.º 10
0
 public cStrategy(ref cSpinControl cSC, ref cDisassemble DisAssemble)
 {
     this.cSC         = cSC;
     this.DisAssemble = DisAssemble;
     OurLastBest      = 0;
     //DisAssemble = new cDisassemble();
     RtnCode        = 0;
     CardsToMove    = new List <card>();
     desCardsToMove = new List <card>();
     srcCardsToMove = new List <card>();
     xBottomMost    = new List <card>();
     xEmpties       = new List <int>();
     xNonEmpties    = new List <int>();
     xTopMost       = new List <card>();
 }
Ejemplo n.º 11
0
        private static bool tbsCompare(ref cSpinControl cSC, int i1, int i2)
        {
            int i, j, k, n = cSC.ThisBoardSeries.Count;

            if (n < 2)
            {
                return(true);
            }
            board nb1 = cSC.ThisBoardSeries[i1];
            board nb2 = cSC.ThisBoardSeries[i2];

            if (nb1.NonEmpties.Count != nb2.NonEmpties.Count)
            {
                return(false);
            }
            if (nb1.Empties.Count != nb2.Empties.Count)
            {
                return(false);
            }
            for (i = 0; i < nb1.NonEmpties.Count; i++)
            {
                k = nb1.NonEmpties[i];
                n = nb1.ThisColumn[k].Cards.Count;
                if (n != nb2.ThisColumn[k].Cards.Count)
                {
                    return(false);
                }
                for (j = 0; j < n; j++)
                {
                    if (nb1.ThisColumn[k].Cards[j].rank != nb2.ThisColumn[k].Cards[j].rank)
                    {
                        return(false);
                    }
                    if (nb1.ThisColumn[k].Cards[j].suit != nb2.ThisColumn[k].Cards[j].suit)
                    {
                        return(false);
                    }
                    if (nb1.ThisColumn[k].Cards[j].bFaceUp != nb2.ThisColumn[k].Cards[j].bFaceUp)
                    {
                        return(false);
                    }
                }
            }
            return(true);
        }
Ejemplo n.º 12
0
 public static void SetSuitableValues(ref cSpinControl cSC, ref board tb)
 {
     if (tb.bIsCompletable)
     {
         if (cSC.MaxValues.MaxInserts != cSC.MaxValues.MaxInsertsWhenSuiting)
         {
             Console.WriteLine("Switching to max resources");
         }
         cSC.MaxValues.MaxInserts  = cSC.MaxValues.MaxInsertsWhenSuiting;
         cSC.MaxValues.TimeOutBest = cSC.MaxValues.MaxTimeoutWhenSuiting;
     }
     else
     {
         if (cSC.MaxValues.MaxInserts != cSC.MaxValues.MinInserts)
         {
             Console.WriteLine("Switching to min resources");
         }
         cSC.MaxValues.MaxInserts  = cSC.MaxValues.MinInserts;
         cSC.MaxValues.TimeOutBest = cSC.MaxValues.MinTimeout;
     }
 }
Ejemplo n.º 13
0
        public static bool tbsCompareSeeds(ref cSpinControl cSC)
        {
            int  i, j, n = cSC.ThisSeed.Seeds.Count;
            bool bResult = true;

            if (n > GlobalClass.MIN_FILTERED_BOARDS)
            {
                n = GlobalClass.MIN_FILTERED_BOARDS;
            }
            if (n < 2)
            {
                return(true);
            }
            for (i = 0; i < n - 1; i++)
            {
                for (j = i + 1; j < n; j++)
                {
                    bResult &= tbsCompareAll(ref cSC, i, j);
                }
            }
            return(bResult);
        }
Ejemplo n.º 14
0
 public static char GetShrinkCode(ref cSpinControl cSC)
 {
     if (cSC.bExceededCountLimit)
     {
         return('L');
     }
     if (cSC.bExceededONEcolLimit)
     {
         return('1');
     }
     if (cSC.bExceededTWOcolLimit)
     {
         return('2');
     }
     if (cSC.bExceededThreecolLimit)
     {
         return('3');
     }
     if (cSC.bSpinTimedOut)
     {
         return('T');
     }
     if (cSC.bSpinDidAllBoards)
     {
         return('D');
     }
     if (cSC.bOutOfSpaceInSTLOOKUP)
     {
         return('S');
     }
     if (cSC.bGotOneSuitAtLeast)
     {
         return('C');
     }
     Debug.Assert(false);
     return(' ');
 }
Ejemplo n.º 15
0
        public static int HandleDeal(ref cSpinControl cSC, bool bDealThruSeed)
        {
            int           m, n = cSC.ThisBoardSeries.Count; // utils.UseThisManyBoards(ref cSC);
            cDealStrategy DealStrategy = new cDealStrategy(ref cSC);
            board         tb = null;
            int           j, nNewBoards = 0;

            if (cSC.BestBoard != null)
            {
                SaveBestBoard(ref cSC);
            }

            if (bDealThruSeed)
            {
                n = cSC.ThisSeed.Seeds.Count;
            }
            if (n > GlobalClass.MAX_FILTERED_BOARDS)
            {
                n = GlobalClass.MAX_FILTERED_BOARDS;
            }
            cSC.BestBoard = null;   // only want the one for the current deal
            for (int i = 0; i < n; i++)
            {
                if (bDealThruSeed)
                {
                    if (i >= cSC.ThisSeed.SeedIndex.Count)
                    {
                        break;
                    }
                    j = cSC.ThisSeed.SeedIndex[i];
                }
                else
                {
                    j = i;
                }
                tb         = cSC.ThisBoardSeries[j];
                nNewBoards = DealStrategy.DealToBoard(ref tb, DateTime.Now, n);
                // nNewBoards mistakenly includes dead boards so dont check for n==m anymore
                cSC.LocalDealCounter++;
                tb.DealCountIndex = cSC.LocalDealCounter;
                // save only the first 12 boards of the deal.  the deal is against the previous deck
                if (i < GlobalClass.MaxDealsToShow)
                {
                    bool bOnLast = ((i == (n - 1)) || (i == (GlobalClass.MaxDealsToShow - 1)));
                    cSC.Deck.SaveBoardAtDeal(bOnLast ? GlobalClass.eSBAD.eAllGathered : GlobalClass.eSBAD.eContinue, ref tb, i);
                    if (tb.MyMoves.TheseMoves.Count() < 6)
                    {
                        int kk = 0;
                    }
                }
                if (nNewBoards > GlobalClass.MinInserts)
                {
                    break;
                }
            }
            m = DealStrategy.GetBoards(ref cSC);
            if (m <= 0)
            {
                if (tb.DealCounter < 5)
                {
                    Debug.Assert(m > 0);
                    Console.WriteLine("problem with handleing deal! m:" + m + " nNewBoards:" + nNewBoards);
                }
                else
                {
                    Console.WriteLine("Game over\n");
                }
                Environment.Exit(0);
            }
            tb = cSC.ThisBoardSeries[0];
            utils.SetSuitableValues(ref cSC, ref tb);
            if (m > GlobalClass.MAX_FILTERED_BOARDS)
            {
                m = GlobalClass.MAX_FILTERED_BOARDS;
            }
            // all will be processed, just want at most 500 results after RunFilter
            if (m < GlobalClass.MIN_FILTERED_BOARDS)
            {
                m = GlobalClass.MIN_FILTERED_BOARDS;
            }
            // want to have at least this many from the filter if possible
            cSC.BestScore = 0;      // this may get new boards into SortedScores at least on the next filter run
            cSC.stlookup.Clear();
            //GlobalClass.bLookForFirstColumn = true;  // ONLY WANT TO DO THIS ONCE FOR VERY FIRST TIME.
            //GlobalClass.bFoundFirstColunn = false;
            return(m);
        }
Ejemplo n.º 16
0
        public static GlobalClass.StrategyType  UseThisManyBoards(ref cSpinControl cSC, ref int NumToUse)
        {
            int i, n = cSC.ThisBoardSeries.Count;
            int iBiggest = 0;

            int[] tsbEmptyDistribution = new int[11] {
                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
            };
            int[] sedEmptyDistribution = new int[11] {
                0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
            };
            Debug.Assert(cSC.ThisBoardSeries.Count > 0);
            Debug.Assert(cSC.ThisSeed.SeedIndex.Count > 0);



            foreach (board tb in cSC.ThisBoardSeries)
            {
                tsbEmptyDistribution[tb.Empties.Count]++;
            }
            for (i = 0; i < cSC.ThisSeed.SeedIndex.Count; i++)
            {
                board tb = cSC.ThisBoardSeries[cSC.ThisSeed.SeedIndex[i]];
                sedEmptyDistribution[tb.Empties.Count]++;
            }

            for (i = 10; i >= 1; i--)
            {
                if (sedEmptyDistribution[i] > 0)
                {
                    iBiggest = i;
                    break;
                }
            }

            if (iBiggest == 0)
            {
                NumToUse = GlobalClass.MAX_FILTERED_BOARDS;    // if no empty columns run thru all boards
                return(GlobalClass.StrategyType.CONTINUE_SPINNING);
            }
            if (iBiggest <= 3)
            {
                NumToUse = GlobalClass.MIN_FILTERED_BOARDS;
                return(GlobalClass.StrategyType.CONTINUE_SPINNING);
            }


            if (iBiggest > 3 && cSC.ThisBoardSeries[0].bIsCompletable)
            {
                NumToUse = 0;
                return(GlobalClass.StrategyType.REDUCE_SUITS); // stop the spinning - switch to end game
            }

            // UNTIL I FIX JOINSUITS
            //if (iBiggest == 3)
            //{
            //    NumToUse = 10;
            //    return GlobalClass.StrategyType.SPIN_JOINSUITS;
            //}
            //if (iBiggest == 2)
            //{
            //    NumToUse = GlobalClass.MIN_FILTERED_BOARDS;
            //    return GlobalClass.StrategyType.RUN_JOINSUITS_INPLACE;
            //}

            //foreach (board tb in cSC.ThisBoardSeries)
            //{
            //    if (tb.NumEmptyColumns == 2)
            //        Console.WriteLine(tb.ID + " " + tb.score + " ");
            //}

            NumToUse = GlobalClass.MIN_FILTERED_BOARDS;
            return(GlobalClass.StrategyType.CONTINUE_SPINNING);
        }
Ejemplo n.º 17
0
        static void Main(string[] args)
        {
            bool         bIsThere = false;
            string       stExt = ".SpiderSolitaireSave-ms";
            string       stTemp, strSpiderBin0;
            string       PathToDirectory;
            string       stSrc = "", stDef = "Spider Solitaire.SpiderSolitaireSave-ms";
            cSpinControl cSC;
            board        InitialBoard;

            stTemp = System.Reflection.Assembly.GetEntryAssembly().Location; // path to executable
            if (args.Count() > 0)
            {
                stSrc = "\\" + args[0];
            }
            else //stSrc = "\\" + stDef;  - not searching for save file anymore
            {
                GiveHelp();
                Environment.Exit(0);
            }
            strSpiderBin0 = System.IO.Path.GetDirectoryName(stTemp) + stSrc;
            bIsThere      = File.Exists(strSpiderBin0);
            if (bIsThere)
            {
                PathToDirectory           = Path.GetDirectoryName(strSpiderBin0) + "\\";
                GlobalClass.strSpiderBin  = strSpiderBin0;
                GlobalClass.strSpiderDir  = PathToDirectory;
                GlobalClass.strSpiderName = PathToDirectory + Path.GetFileNameWithoutExtension(strSpiderBin0);
                GlobalClass.strSpiderExt  = Path.GetExtension(strSpiderBin0);
                cSC          = new cSpinControl(); // this created the default xml "filename"
                InitialBoard = new board();
                cSC.Deck     = new cBuildDeck(strSpiderBin0, XMLtoRead, ref cSC);
                if (args.Count() < 2) // just want to look at the xml
                {
                    cSC.Deck.GetBoardFromSpiderSave(ref InitialBoard);
                }
                else
                {
                    string stDes = stDef;
                    if (args.Count() == 3)
                    {
                        stDes = args[2];
                    }
                    if (!stDes.Contains(stExt))
                    {
                        stDes += stExt;
                    }
                    if (args[0] == stDes)
                    {
                        Console.WriteLine("cannot have same output file name as the input saved game\n");
                        Environment.Exit(0);
                    }
                    stTemp = PathToDirectory + Path.GetFileNameWithoutExtension(args[1]);
                    if (GlobalClass.strSpiderName == stTemp)
                    {
                        Console.WriteLine("should not have same input saved game name as the input xml filename\n");
                        Console.WriteLine("or input xml file will be over written as that filename used for temp storage\n");
                        Environment.Exit(0);
                    }
                    GlobalClass.strSpiderOutputBinary = cSC.BIN_Diag_filename = PathToDirectory + "\\" + stDes;
                    cSC.Deck.GetBoardFromSpiderSave(ref InitialBoard);  // read in the saved game and also create the matching xml
                    cSC.XML_Diag_filename = PathToDirectory + args[1];
                    cSC.Deck.WriteBoardMergingXML();
                }
            }
        }
Ejemplo n.º 18
0
 public cTest(ref cSpinControl cSC, ref cStrategy Strategy)
 {
     this.Strategy = Strategy;
     this.cSC      = cSC;
 }
Ejemplo n.º 19
0
 public cReduce(ref cSpinControl cSC, ref cDisassemble Disassemble, ref cStrategy Strategy)
 {
     this.Disassemble = Disassemble;
     this.Strategy    = Strategy;
     this.cSC         = cSC;
 }
Ejemplo n.º 20
0
        public void ReCreateBinFile(ref board tb, ref cSpinControl cSC, string strPrefix)
        {
            long   nLen1, nLen = 1048576;
            int    i, j, n;
            int    DealID          = cSC.LocalDealCounter; // this is the deals that are done to the "working deal" which is the board deal counter.
            string strFullpathname = "";

            if (strPrefix == "")
            {
                strFullpathname = GlobalClass.strSpiderOutputBinary;
            }
            else
            {
                strFullpathname = GlobalClass.strSpiderDir + strPrefix + ".SpiderSolitaireSave-ms";
            }


            //FileStream inStream = File.OpenRead(strFullpathname + ".hdr");
            //BinaryReader br = new BinaryReader(inStream);
            //nLen = inStream.Length;
            //Debug.Assert(nLen == 0x2028);



            if (File.Exists(strFullpathname))
            {
                Debug.Assert(false);
            }

            FileStream   outStream = File.Create(strFullpathname);
            BinaryWriter bw        = new BinaryWriter(outStream);


            // get the hdr
            byte[] outbuf = new byte[256000];
            for (j = 0; j < 0x2028; j++)
            {
                outbuf[j] = cSC.Hdr[j];
            }


            nLen = cSC.PngArray.Length;
            // get the png file
#if SAVE_PNG
            inStream = File.OpenRead(strFullpathname + ".png");
            nLen     = inStream.Length;
            br       = new BinaryReader(inStream);
            br.Read(outbuf, 0x2028, (int)nLen);
            nLen1 = nLen + 0x2028;
#endif
            nLen1 = 0x2028;
            for (i = 0; i < nLen; i++)
            {
                outbuf[nLen1] = cSC.PngArray[i];
                nLen1++;
            }

            MakeXmlFile(strFullpathname, ref tb, ref cSC);
            n = sbXML.Length;
            string sbTemp = sbXML.ToString();
            j = (int)nLen1;
            // convert n into bytes and append ff fe so one could get "c6 18 01 00 ff fe"
            byte[] b6 = new byte[8];
            GetUnk6(ref b6, 6 + n * 2); // added 2 to fix problem and added another 2 for two more nulls but 0xa is missing

            for (i = 0; i < 6; i++)
            {
                outbuf[j] = b6[i];
                j++;
            }
            for (i = 0; i < n; i++)
            {
                outbuf[j] = (byte)sbTemp[i];
                j++;
                outbuf[j] = 0;
                j++;
            }
            outbuf[j] = 0;
            j++;
            outbuf[j] = 0x0a;
            j++;
            bw.Write(outbuf, 0, j + 2);
            bw.Close();
        }
Ejemplo n.º 21
0
        //complete starts off with  x 110 y 380  then x goes to 140 (increments by 30

        private void MakeXmlFile(string strFullPathName, ref board tb, ref cSpinControl cSC)
        {
            bool bFaceUp;       // deck:  all are false except the last enabled
            bool bEnabled;      // complete: all are faceup and all enabled are false

            sbXML = new StringBuilder(16384);
            XmlWriterSettings settings = new XmlWriterSettings();

            settings.Indent             = true;
            settings.IndentChars        = ("    ");
            settings.NewLineChars       = "\n";
            settings.OmitXmlDeclaration = true;

            using (XmlWriter writer = XmlWriter.Create(sbXML, settings)) //(strFullPathName + "_bin.xml", settings))

//            using (XmlWriter writer = XmlWriter.Create(strFullPathName + "_bin.xml", settings))
            {
                // Write XML data.
                writer.WriteStartElement("Root");
                writer.WriteStartElement("GameState");
                writer.WriteElementString("Version", "7");
                writer.WriteElementString("GameSeed", cSC.GameSeed.ToString());
                writer.WriteElementString("Score", tb.score.ToString());             // 2018 tb.score.ToString());
                writer.WriteElementString("Moves", (1 + tb.DealCounter).ToString()); // (tb.NumMoves + tb.MyMoves.TheseMoves.Count).ToString());
                writer.WriteEndElement();                                            // gamestate
                writer.WriteStartElement("CardTable");
                writer.WriteStartElement("CardStacks");
                cCardStack ccsPtr;
                int        nCardStack = 0;
                int        nDirection = 1;

                foreach (column col in tb.ThisColumn)
                {
                    ccsPtr = col.CardStack;
                    int    ccsPtrX = ccsPtr.X;
                    int    ccsPtrY = ccsPtr.Y;
                    int    j = 0; // count cards as only last one is enabled
                    int    dX = 0, dY = 0;
                    string stackName = "";
                    switch (nDirection)
                    {
                    case 1: stackName = "Stack" + (col.CardStack.stackid).ToString();
                        dY            = 7;
                        dX            = -7;
                        break;

                    case 2: stackName = "Deck";
                        dX            = -6;
                        break;

                    case 3: stackName = "Complete";
                        dX            = 30; // origin of X was 110
                        dY            = 0;  // origin of Y was 380
                        break;
                    }
                    writer.WriteStartElement("CardStack");
                    writer.WriteElementString("NumEndCardsSpaced", ccsPtr.NumEndCardsSpaced.ToString());
                    writer.WriteElementString("X", ccsPtr.X.ToString());
                    writer.WriteElementString("Y", ccsPtr.Y.ToString());
                    writer.WriteElementString("Name", stackName);
                    writer.WriteElementString("Direction", nDirection.ToString());
                    writer.WriteStartElement("Cards");
                    foreach (card crd in col.Cards)
                    {
                        writer.WriteStartElement("Card");
                        writer.WriteElementString("X", ccsPtrX.ToString());
                        writer.WriteElementString("Y", ccsPtrY.ToString());
                        bFaceUp  = crd.bFaceUp;
                        bEnabled = bFaceUp;

                        if (nDirection == 3)
                        {
                            bFaceUp  = true;
                            bEnabled = false;
                        }
                        else if (nDirection == 2)
                        {
                            bFaceUp  = false;
                            bEnabled = (j == (col.Cards.Count - 1));
                        }

                        if (nDirection == 1)
                        {
                            ccsPtrY += dY;
                        }
                        writer.WriteElementString("Name", GlobalClass.ProperName(crd));
                        writer.WriteElementString("Type", crd.type.ToString());
                        writer.WriteElementString("FaceUp", bFaceUp.ToString().ToLower());
                        writer.WriteElementString("Enabled", bEnabled.ToString());

                        if (bFaceUp && nDirection < 3)
                        {
                            dY = 23;
                        }

                        if (((1 + j) % 13) == 0)
                        {
                            ccsPtrX += dX;
                            if (nDirection != 1)
                            {
                                ccsPtrY += dY;
                            }
                        }

                        j++;
                        writer.WriteEndElement(); // card
                    }
                    writer.WriteEndElement();     // cards
                    writer.WriteEndElement();     //CardStack
                    nCardStack++;
                    if (nCardStack == 10)
                    {
                        nDirection = 2;
                    }
                    if (nCardStack == 11)
                    {
                        nDirection = 3;
                    }
                    // need to write out the completed stack eventually!!
                }
                writer.WriteEndElement();   // cardstacks
                writer.WriteEndElement();   // cardtable
                writer.WriteEndElement();   // root
                writer.Flush();
                if (strFullPathName.Contains("SUIT"))
                {
                    Console.WriteLine(" Wrote out a binary suit file: " + strFullPathName);
                }
                else if (strFullPathName.Contains("DEAL"))
                {
                    Console.WriteLine(" Wrote out a binary deal file: " + strFullPathName);
                }
                else
                {
                    Console.WriteLine(" replaced with a new binary deal file: " + strFullPathName);
                }
                foreach (cSuitedStatus cSS in tb.SuitStatus)
                {
                    for (int i = 0; i < cSS.NumCompletedAndRemoved; i++)
                    {
                        Console.WriteLine("Removed suit:" + GlobalClass.SuitNames[cSS.index]);
                    }
                }
            }
        }
Ejemplo n.º 22
0
        static void Main(string[] args)
        {
            bool   bIsThere      = false;
            string strSpiderBin0 = "";
            string PathToDirectory;
            string stTemp = System.Reflection.Assembly.GetEntryAssembly().Location; // path to executable

            // KnownFolderFinder.EnumerateKnownFolders();   // this was used for testing purposes
            // GlobalClass.InitExceptions();

            // if argument is supplied and extension is a saved game, then use that
            GlobalClass.bLookForFirstColumn = true;
            GlobalClass.bFoundFirstColunn   = false;
            Console.WriteLine("Spider(v) 1.0; 5-20-2018; Copyright Joseph Stateson:  [email protected]\n");

            if (args.Count() > 0)
            {
                if (args[0].Contains(".SpiderSolitaireSave-ms"))
                {
                    string path = Directory.GetCurrentDirectory();
                    strSpiderBin0 = path + "\\" + args[0];
                    bIsThere      = File.Exists(strSpiderBin0);
                    Debug.Assert(bIsThere);
                    GlobalClass.strSpiderBin = strSpiderBin0;
                }
            }
            else
            {
                // look for file in current director and use that one
                strSpiderBin0 = System.IO.Path.GetDirectoryName(stTemp) + "\\Spider Solitaire.SpiderSolitaireSave-ms";
                bIsThere      = File.Exists(strSpiderBin0);
            }
            if (!bIsThere)
            {
                //Attempt to find where the saved spider file is located.  Normally at c:\user\username but the windows MOVE property might
                //have been used to relocat the file.  In addition,  OneDrive may or may not be in the path returned by SpecialFolder

                strSpiderBin0 = Environment.GetFolderPath(Environment.SpecialFolder.Personal);
                // the above is usually user\stateson\documents
                GlobalClass.strSpiderBin = strSpiderBin0.Replace("Documents", "Saved Games\\Microsoft Games\\Spider Solitaire\\Spider Solitaire.SpiderSolitaireSave-ms");
                bIsThere = File.Exists(GlobalClass.strSpiderBin);
                if (!bIsThere)
                {
                    // user has made it hard to find, try looking in the registry in case the windows 10 "MOVE" relocated Documents.
                    // we need to find the original Documents location, not the new one
                    Console.WriteLine("could not find " + GlobalClass.strSpiderBin + "\n");
                    PathToDirectory          = KnownFolderFinder.GetFolderFromKnownFolderGUID(new Guid("{FDD39AD0-238F-46AF-ADB4-6C85480369C7}"));
                    GlobalClass.strSpiderBin = PathToDirectory.Replace("Documents", "Saved Games\\Microsoft Games\\Spider Solitaire\\Spider Solitaire.SpiderSolitaireSave-ms");
                    bIsThere = File.Exists(GlobalClass.strSpiderBin);
                    if (!bIsThere)
                    {
                        string strEXE;
                        Console.WriteLine("nothing here also " + GlobalClass.strSpiderBin + "\n");
                        Console.WriteLine("Trying local directory where this .exe program resides\n");
                        strEXE          = System.Reflection.Assembly.GetEntryAssembly().Location;
                        PathToDirectory = System.IO.Path.GetDirectoryName(strSpiderBin0);
                        Console.WriteLine("Looking here: " + PathToDirectory + "\n");
                        strSpiderBin0 = PathToDirectory + "\\Spider Solitaire.SpiderSolitaireSave-ms";
                        if (!File.Exists(strSpiderBin0))
                        {
                            Console.WriteLine("Giving up, cannot find " + strSpiderBin0);
                            Environment.Exit(0);
                        }
                        else
                        {
                            GlobalClass.strSpiderBin = strSpiderBin0;
                        }
                    }
                    else
                    {
                        strSpiderBin0 = GlobalClass.strSpiderBin;
                    }
                }
                else
                {
                    strSpiderBin0 = GlobalClass.strSpiderBin;
                }
            }
            else
            {
                GlobalClass.strSpiderBin = strSpiderBin0;
            }
            PathToDirectory = Path.GetDirectoryName(GlobalClass.strSpiderBin) + "\\";
            GlobalClass.strSpiderOutputBinary = GlobalClass.strSpiderBin = strSpiderBin0;
            GlobalClass.strSpiderDir          = PathToDirectory;
            GlobalClass.strSpiderName         = PathToDirectory + Path.GetFileNameWithoutExtension(strSpiderBin0);
            GlobalClass.strSpiderExt          = Path.GetExtension(strSpiderBin0);
            ClearDir(PathToDirectory);  // erases files with pattern DEAL*, SUIT*, *.mov and adeck and those xml ones also
            cSpinControl cSC = new cSpinControl();

            DisAssemble    = new cDisassemble(ref cSC);
            Suitable       = new csuitable(ref cSC, ref DisAssemble);
            Strategy       = new cStrategy(ref cSC, ref DisAssemble);
            Reduce         = new cReduce(ref cSC, ref DisAssemble, ref Strategy);
            cSC.Strategy   = Strategy;
            cSC.Suitable   = Suitable;
            cSC.JoinSuited = new cJoinSuited(ref cSC);

            Test = new cTest(ref cSC, ref Strategy);

//            Test.RunTest();

            // http://stackoverflow.com/questions/177856/how-do-i-trap-ctrl-c-in-a-c-sharp-console-apphttp://stackoverflow.com/questions/177856/how-do-i-trap-ctrl-c-in-a-c-sharp-console-app
            try
            {
                SolveBoard(ref cSC, GlobalClass.strSpiderBin);
            }
            catch (Exception e)
            {
                if (e.Message != "Spider")
                {
                    throw e;
                }
                //GlobalClass.eExceptionType eID = (GlobalClass.eExceptionType) e.Data["ID"];
                string msg = (string)e.Data["MSG"];
                Console.WriteLine(msg);
                Environment.Exit(0);
            }
        }
Ejemplo n.º 23
0
 public csuitable(ref cSpinControl cSC, ref cDisassemble Disassemble)
 {
     this.cSC          = cSC;
     this.Disassemble  = Disassemble;
     NumberCompletable = 0;
 }
Ejemplo n.º 24
0
        static void SolveBoard(ref cSpinControl cSC, string strSpiderBin)
        {
            int m = GlobalClass.MAX_FILTERED_BOARDS;

            GlobalClass.StrategyType gcst = GlobalClass.StrategyType.CONTINUE_SPINNING;
            board InitialBoard            = new board();

            cSC.Deck             = new cBuildDeck(strSpiderBin, XMLtoRead, ref cSC);
            MakeAllPossibleMoves = new cSpinAllMoves(ref cSC);
            cSC.Deck.GetBoardFromSpiderSave(ref InitialBoard);
            if (InitialBoard.NumEmptyColumns > 0)
            {
                GlobalClass.bFoundFirstColunn = false;  // started with an empty column, no need to display it.
            }
            InitialBoard.ShowBoard();

            cSC.cMXF = new cMergeXmlFile();

            if (cSC.bJustReadXML)
            {
                Console.WriteLine(" Did you mean to read a pre-existing XML file?\n - close window to abort\n - or press N to delete the XML file and abort\n - or press Y to continue");
                if (cSC.EventList.Count > 0)
                {
                    Console.WriteLine(" There are " + cSC.EventList.Count + " events in the event list");
                    Console.WriteLine(cSC.Deck.strEventInfoPrompt);
                }
                ConsoleKeyInfo cki = Console.ReadKey();
                Console.WriteLine("");
                if (cki.Key.ToString().ToLower() == "n")
                {
                    File.Delete(cSC.XML_Diag_filename);
                    Environment.Exit(0);
                }
                else
                {
                    string strA = cki.KeyChar.ToString();
                    int    A    = -1;
                    int.TryParse(strA, out A);

                    if (A >= 1 && A < 7)
                    {
                        int    RequiredOffset = 0;
                        int    RequiredDeal   = A;
                        string strCmd         = Console.ReadLine().ToLower();
                        strA         = strCmd.Substring(0, 1);
                        InitialBoard = null;
                        if (strA == "m")  //Format is 2m34 or 3M45
                        {
                            strCmd         = strCmd.Substring(1);
                            RequiredOffset = Convert.ToInt32(strCmd);
                            bool bResult = cSC.Deck.AdvanceToPosition(RequiredDeal, RequiredOffset, out InitialBoard);
                            CallExit();
                        }
                        else
                        {
                            if (strA == "s") // format is 2s 3S , etc ..   show all best scores
                            {
                                bool bResult = cSC.Deck.ShowAllBestScores(RequiredDeal, out InitialBoard);
                                CallExit();
                            }
                            else if (strA == "t") // format is 2t45 3t9 , etc .. trace using stlookup
                            {                     // deals 2, 3, and set breakpoint in debugger at the callout for the 45, 9, etc
                                RequiredOffset = Convert.ToInt32(strCmd.Substring(1));
                                bool bResult = cSC.Deck.AddBoardsToLookup(RequiredDeal, RequiredOffset);
                                CallExit();
                            }
                            else
                            {
                                Console.WriteLine("Unknown key code.  One of M,S,m,s only");
                                CallExit();
                            }
                        }
                    }
                    else
                    {
                        bool bResult = cSC.Deck.AdvanceSaveBoard(cki.Key.ToString().ToLower(), out InitialBoard);
                        Debug.Assert(false);
                    }
                }
            }



            //Suitable.CheckSuitability(ref InitialBoard);
            // the above is not critical to the program as yet, just good info about unexposed cards

            //cSC.Suitable.CombineLikeSuits(ref InitialBoard);

            MakeAllPossibleMoves.AddInitialBoard(ref InitialBoard, GlobalClass.FIRST_CARD, ref Suitable);


            //cSC.JoinSuited.SpinSuitedJoinables(ref cSC.ThisBoardSeries);


            //if (InitialBoard.bIsCompletable)                PerformReduceSuits(ref cSC, 20);

            //Console.CancelKeyPress += delegate(object sender, ConsoleCancelEventArgs e)
            //{
            //    e.Cancel = true;
            //    Program.keepRunning = false;
            //};

            while (true) // (Program.keepRunning)
            {
                RunAway--;
                if (RunAway < 0)
                {
                    Console.WriteLine("hit any key except x: TBS:" + cSC.ThisBoardSeries.Count + "  NBS:" + cSC.NextBoardSeries.Count);
                    ConsoleKeyInfo cki = Console.ReadKey();
                    if (cki.KeyChar == 'x')
                    {
                        Environment.Exit(0);
                    }
                }

                bool b1 = MakeAllPossibleMoves.RunFilter(m);    // m is max to allow after applying filter

                bool bSameSeed = cSC.PrevSeed.bSameSeed(ref cSC.ThisSeed);
                if (cSC.bOutOfSpaceInSTLOOKUP)
                {
                    Console.WriteLine("ran out of space and had to clear stlookup");
                    cSC.stlookup.Clear();
                    cSC.bOutOfSpaceInSTLOOKUP = false;
                }
                if (cSC.bSpinDidAllBoards)
                {
                    int iAny = 0;
                    for (int i = 0; i < cSC.ThisBoardSeries.Count; i++)
                    {
                        board nb = cSC.ThisBoardSeries[i];
                        if (cSC.Suitable.CombineLikeSuits(ref nb))
                        {
                            iAny++;
                        }
                    }
                    if (iAny > 0)
                    {
                        cSC.bSpinDidAllBoards = false;
                        m = cSC.ThisBoardSeries.Count;
                        Console.WriteLine("Cannot deal but found " + iAny.ToString() + "  new boards using join suited" + cSC.bSpinDidAllBoards);
                    }
                }
                if (cSC.bSpinDidAllBoards || bSameSeed || cSC.bStopThisRun)
                {
                    m = HandleDeal(ref cSC, false);
                    Console.WriteLine("Handled deal with m:" + m.ToString() + "  bSpin:" + cSC.bSpinDidAllBoards + " SameSeed:" + bSameSeed, " StopRun:" + cSC.bStopThisRun);
                    Console.WriteLine("TBS: " + cSC.ThisBoardSeries.Count + " NBS: " + cSC.NextBoardSeries.Count);
                    cSC.bTrace = true;
                }
                else
                {
                    // unable to finish all boards -or- didnt generate any boards other then the same seeds
                    if (cSC.SortedScores.Count == 0)
                    {
                        // no larger scores were found during the last run:  use ThisSeed
                        m = HandleDeal(ref cSC, true);
                        Console.WriteLine("Handled deal from SortedScores.count=0 m:" + m.ToString());
                    }
                    else
                    {
                        gcst = utils.UseThisManyBoards(ref cSC, ref m);
                        Console.WriteLine("HNS: " + m + "  type " + gcst.ToString());
                        if (gcst != GlobalClass.StrategyType.CONTINUE_SPINNING)
                        {
                            Console.WriteLine("Seem we are to reduce:" + m);
                            HandleNewStrategy(gcst, ref cSC, ref m);
                        }
                    }
                }
            }
            //if (!Program.keepRunning)
            //{
            //    cSC.BestBoard.ShowBoard();  // 11nov2012 added this ctrl-c stuff
            //}
        }
Ejemplo n.º 25
0
 public cJoinSuited(ref cSpinControl cSC)
 {
     this.cSC = cSC;
 }