Ejemplo n.º 1
0
        /// <summary>
        /// Helper tworzący początkowe ustawienia walców. Początkowa pozycja brana jest z <see cref="SpinnerConfig.Rno"/>
        /// </summary>
        /// <param name="config">Konfiguracja spinnera</param>
        /// <returns>Linie ustalane na początku gry.</returns>
        private PayLine[] CreateInitialWinningLine(SpinnerConfig config)
        {
            PayLine[] winningLines = new PayLine[config.PayLines];

            Dictionary <int, Dictionary <int, int> > reelSymbolsOccurance = this.CreateSymbolsOccurancesTable();

            int[] previousLine = null;
            for (int lineIndex = config.Rno, done = 0, maxAttemptesAfterFail = config.Lines.Length;
                 done < config.PayLines && maxAttemptesAfterFail > 0;
                 lineIndex++, done++)
            {
                if (lineIndex > config.Lines.Length - 1)
                {
                    //Przekręcamy licznik
                    lineIndex = 0;
                }

                int[] line = config.Lines[lineIndex];
                if (this.IsLineValid(reelSymbolsOccurance, line, previousLine) == false)
                {
                    done--;

                    // Podejmiemy tyle prób, ile jest linii
                    maxAttemptesAfterFail--;

                    // Przechodzimy do następnej linii, bo tej wziąć nie możemy
                    continue;
                }

                // Dodajemy do wyników nową linię
                winningLines[done] = new PayLine(lineIndex, line);

                // Podbijamy occurance dla każdego symbolu
                for (int reel = 0; reel < line.Length; reel++)
                {
                    int reelSymbol = line[reel];
                    reelSymbolsOccurance[reel][reelSymbol]++;
                }

                previousLine = line;
            }

            return(winningLines);
        }
Ejemplo n.º 2
0
        /// <summary>
        /// <inheritdoc/>
        /// </summary>
        public void Spin()
        {
            // TODO ReelsSymbolsOccurance

            Dictionary <int, Dictionary <int, int> > reelSymbolsOccurance = this.CreateSymbolsOccurancesTable();

            PayLine[] winningLines = new PayLine[_payLinesQuantity];

            int[] previousLine = null;

            int lineAttempt = 0;

            // Jeśli danej linii nie udało się zrobić to podbijamy index
            for (int lineIndex = 0, maxAttemptesAfterFail = this.Lines.Length; lineIndex < _payLinesQuantity; lineIndex++, maxAttemptesAfterFail--)
            {
                PayLine previousPayLine = this.PayLines[lineIndex];
                int[]   lineChoosen     = new int[previousPayLine.Line.Length];

                for (int reelIndex = 0; reelIndex < previousPayLine.Line.Length; reelIndex++)
                {
                    // index po zakręceniu bębnem (skorygowany o spin). Jeśli ostatnia próba nie powiodła się to korygujemy index o 1
                    int reelSpinIndex = previousPayLine.Index + _spin[reelIndex] + lineAttempt;
                    if (reelSpinIndex >= this.Lines.Length)
                    {
                        // Skoro przekręciliśmy licznik - to zaczynamy od nowa
                        reelSpinIndex -= this.Lines.Length;
                    }

                    int reelSymbol = this.Lines[reelSpinIndex][reelIndex];

                    lineChoosen[reelIndex] = reelSymbol;
                }

                // Jeśli linia niewalidna i mamy jeszce próby to
                if (this.IsLineValid(reelSymbolsOccurance, lineChoosen, previousLine) == false && lineAttempt < this.Lines.Length)
                {
                    // To będzie kolejna próba
                    lineAttempt++;

                    lineIndex--;

                    // TODO co z tymi próbami?

                    // Podejmiemy tyle prób, ile jest linii
                    maxAttemptesAfterFail--;

                    // Przechodzimy do następnej linii, bo tej wziąć nie możemy
                    continue;
                }

                // Mamy całą linię, teraz musimy odszukać ją w tablicy, bo walce mogą kręcić się o różne wartości
                // ważne, żeby zacząć szukać od poprzedniego miejsca

                winningLines[lineIndex] = _linesSearcher.Find(lineChoosen, previousPayLine.Index);
                lineAttempt             = 0;

                // Podbijamy occurance dla każdego symbolu
                for (int reel = 0; reel < lineChoosen.Length; reel++)
                {
                    int reelSymbol = lineChoosen[reel];
                    reelSymbolsOccurance[reel][reelSymbol]++;
                }

                previousLine = lineChoosen;
            }

            // TODO - kiedy nie będziemy w stanie ułożyć tych linii? Może ilość prób jest tutaj zbędne? Może trzeba założyć mniejsze zło
            // i jeśli jakiś config nie pozwoli nam na wygenerowanie takich liczb to ustawimy przypadkowe wyniki?
            // TODO przeanalizować i opisać algorytm

            this.PayLines = winningLines;
            this.Rno++;
        }
Ejemplo n.º 3
0
 static bool IsFound(PayLine result)
 {
     return(result is PayLineEmpty == false);
 }
Ejemplo n.º 4
0
 /// <summary>
 /// Próbuje znaleźć daną linię  w całej kolekcji. Rzuci wyjątek jak nic nie znajdzie, jeśli ktoś poda linie, której nie ma w kolekcji.
 /// </summary>
 /// <param name="startIndex">Od którego miejsca szukamy? (wyłącznie, bo zaczniemy od następnego). -1 oznacza, żę od początku</param>
 /// <param name="line">szukana linia</param>
 /// <returns></returns>
 public PayLine Find(int[] line, int startIndex = -1)
 {
     PayLine result = this.Search(startIndex, line);