示例#1
0
        private void CheckNeighborPossibleMove(Direction direction)
        {
            GemController neighbor = GetNeighbor(direction);

            if ((needToCheckNeighborPossibleMove & direction) == direction && neighbor != null && neighbor.IsActive)
            {
                bool havesamepossiblematch = false;
                foreach (PossibleMatch pm in neighbor.PossibleMatches)
                {
                    if (PossibleMatches.Contains(pm))
                    {
                        havesamepossiblematch = true;
                    }
                }
                if (havesamepossiblematch)
                {
                    neighbor.GetNeighbor(direction)?.CheckForPossibleMove();
                }
                else
                {
                    neighbor.CheckForPossibleMove();
                }
            }
            needToCheckNeighborPossibleMove &= (~direction);
        }
            public static Fixture GenerateFixture()
            {
                Fixture         fixture         = new Fixture();
                PossibleMatches possibleMatches = new PossibleMatches();

                Round firstRound = RoundGenerator.GenerateRound();

                fixture.Rounds.Add(firstRound);
                PrintRound(fixture, firstRound);


                foreach (Match m in firstRound.Matches)
                {
                    possibleMatches.Matches.Remove(m);
                }

                int attemptsToGenerateRound = 0;

                while (fixture.Rounds.Count < MAX_ROUNDS)
                {
                    Round possibleRound = RoundGenerator.GenerateRound();

                    if (!fixture.ContainsRound(possibleRound))
                    {
                        attemptsToGenerateRound = 0;
                        fixture.Rounds.Add(possibleRound);
                        PrintRound(fixture, possibleRound);
                        foreach (Match m in possibleRound.Matches)
                        {
                            possibleMatches.Matches.Remove(m);
                        }
                    }
                    else
                    {
                        attemptsToGenerateRound++;
                        if (attemptsToGenerateRound > 1000)
                        {
                            Round remainingRound = RoundGenerator.GenerateRoundFromList(possibleMatches.Matches);
                            fixture.Rounds.Add(remainingRound);
                            PrintRound(fixture, remainingRound, true);
                            attemptsToGenerateRound = 0;
                        }
                    }
                }
                RoundGenerator.CleanList();

                if (!fixture.IsValid())
                {
                    PrintInvalidFixtureMessage();
                }

                return(fixture);
            }
示例#3
0
    public void CheckMatches()
    {
        List <List <GridObject> > matches = Matches();

        if (matches.Count() > 0)
        {
            audio.PlayOneShot(matchSound);
            Debug.Log("checking matches");
            // Add the scores
            foreach (List <GridObject> matchSequence in matches)
            {
                score.AddForMatch(matchSequence);
            }
            // Then destroy the objects
            foreach (List <GridObject> matchSequence in matches)
            {
                foreach (GridObject gridObject in matchSequence)
                {
                    grid.RemoveObject(gridObject);
                }
            }
            grid.OnGridObjectsDestroyed();
        }
        else if (!PossibleMatches().HasMatches())
        {
            Debug.Log("no matches");
            audio.PlayOneShot(noMovesSound);
            grid.ResetBoard();
        }
        else
        {
            score.matchesCombo = 0;
        }
        cachedMatches         = null;
        CachedPossibleMatches = null;
        score.EndSequence();

        //PossibleMatches ();
    }
示例#4
0
    public PossibleMatches PossibleMatches()
    {
        if (CachedPossibleMatches == null)
        {
            CachedPossibleMatches = new PossibleMatches();
            foreach (List <Vector3> row in grid.Successions())
            {
                bool          isAtEndOfMatch = false;
                PossibleMatch currentMatch   = new PossibleMatch(this);
                PossibleMatch nextMatch      = null;
                foreach (Vector3 point in row)
                {
                    GridObject currentObject = grid.ObjectAt(point);
                    if (nextMatch == null || !nextMatch.MatchObjects.Contains(currentObject))
                    {
                        bool currentMatchFromNextMatch = false;
                        if (nextMatch != null)
                        {
                            if (nextMatch.MatchObjects.Count > 0)
                            {
                                Debug.Log("setting current match from next match. next match start " + nextMatch.MatchObjects.First().Position() + " next match end: " + nextMatch.MatchObjects.Last().Position() + " current object: " + currentObject.Position());
                            }
                            else
                            {
                                Debug.Log("EMPTY: setting current match from next match EMPTY");
                            }
                            currentMatch = nextMatch;
                            nextMatch    = null;
                            currentMatchFromNextMatch = true;
                        }
                        if (currentMatch.Matches(currentObject))
                        {
                            currentMatch.AddMatch(currentObject);
                        }
                        else
                        {
                            isAtEndOfMatch = true;
                        }

                        int trailingIndex = row.IndexOf(point);
                        if (row.Count() == trailingIndex)
                        {
                            isAtEndOfMatch = true;
                        }
                        // split
                        if (isAtEndOfMatch)
                        {
                            bool foundSplit = false;
                            if (trailingIndex + 1 < row.Count())
                            {
                                GridObject nextNextObj = grid.ObjectAt(row.ElementAt(trailingIndex + 1));
                                if (currentMatch.Matches(nextNextObj))
                                {
                                    PossibleMatch splitMatch = currentMatch.Duplicate();
                                    splitMatch.Switch.Inhibitor = currentObject;
                                    splitMatch.AddMatch(nextNextObj);
                                    List <GridObject> perpMatches = new List <GridObject> ();
                                    foreach (GridObject matchObj in grid.AdjacentGridObjects(currentObject))
                                    {
                                        if (splitMatch.Matches(matchObj))
                                        {
                                            perpMatches.Add(matchObj);
                                        }
                                    }
                                    // if we have a perpendicular match, see if there's enough for a split
                                    if (perpMatches.Count() > 0)
                                    {
                                        int  sequenceIndex = trailingIndex;
                                        bool isAtEnd       = false;
                                        nextMatch = new PossibleMatch(this);
                                        nextMatch.AddMatch(nextNextObj);
                                        while (!isAtEnd)
                                        {
                                            sequenceIndex = sequenceIndex + 1;
                                            if (sequenceIndex < row.Count())
                                            {
                                                nextNextObj = grid.ObjectAt(row.ElementAt(sequenceIndex));
                                                if (splitMatch.Matches(nextNextObj))
                                                {
                                                    splitMatch.AddMatch(nextNextObj);
                                                    nextMatch.AddMatch(nextNextObj);
                                                }
                                                else
                                                {
                                                    isAtEnd = true;
                                                }
                                            }
                                            else
                                            {
                                                isAtEnd = true;
                                            }
                                        }
                                        if (splitMatch.HasPotentialPossibleMatch())
                                        {
                                            foundSplit = true;
                                            foreach (GridObject matchObj in perpMatches)
                                            {
                                                PossibleMatch perpMatch = splitMatch.Duplicate();
                                                perpMatch.Switch.Trigger = matchObj;
                                                CachedPossibleMatches.Add(perpMatch);
                                            }
                                        }
                                    }
                                }
                            }


                            if (currentMatch.HasPotentialPossibleMatch())
                            {
                                // leading

                                if (!currentMatchFromNextMatch)
                                {
                                    int leadingIndex = row.FindIndex(pt => pt == currentMatch.MatchObjects.First().Position()) - 1;
                                    if (leadingIndex >= 0)
                                    {
                                        GridObject leadingObj = grid.ObjectAt(row.ElementAt(leadingIndex));

                                        foreach (GridObject matchObj in grid.AdjacentGridObjects(leadingObj))
                                        {
                                            if (currentMatch.Matches(matchObj))
                                            {
                                                PossibleMatch leadingMatch = currentMatch.Duplicate();
                                                leadingMatch.Switch.Inhibitor = leadingObj;
                                                leadingMatch.Switch.Trigger   = matchObj;
                                                CachedPossibleMatches.Add(leadingMatch);
                                            }
                                        }
                                    }
                                }

                                // trailing
                                if (!foundSplit)
                                {
                                    foreach (GridObject matchObj in grid.AdjacentGridObjects(currentObject))
                                    {
                                        if (currentMatch.Matches(matchObj))
                                        {
                                            PossibleMatch trailingMatch = currentMatch.Duplicate();
                                            trailingMatch.Switch.Inhibitor = currentObject;
                                            trailingMatch.Switch.Trigger   = matchObj;
                                            CachedPossibleMatches.Add(trailingMatch);
                                        }
                                    }
                                }
                            }
                            isAtEndOfMatch = false;
                            currentMatch   = new PossibleMatch(this);
                            currentMatch.AddMatch(currentObject);
                        }
                    }
                }
                // have to check if the final match is big enough
            }
        }
        return(CachedPossibleMatches);
    }