// SUSTITUÍ EL LINKEDHASHSET DE JAVA POR HASHSET SOLAMENTE... SE ME HACE RARO QUE SE DEVUELVA UN HASHSET, LO NORMAL SERÍA UNA LIST, Y POR DENTRO IMPLEMENTAR CON ARRAYLIST O ALGO
            public HashSet <Operator> Operators(object setup)
            {
                // Lo que entra es un problema, un SlidingPuzzle
                SlidingPuzzle puzzle = (SlidingPuzzle)setup;

                HashSet <Operator> operators = new HashSet <Operator>();

                // Esto se lee: Puedo mover el hueco hacia arriba, o puedo mover la pieza de arriba del hueco
                if (puzzle.CanMoveUp(puzzle.GapPosition))
                {
                    operators.Add(SlidingPuzzleSolver.UP);
                }
                if (puzzle.CanMoveDown(puzzle.GapPosition))
                {
                    operators.Add(SlidingPuzzleSolver.DOWN);
                }
                if (puzzle.CanMoveLeft(puzzle.GapPosition))
                {
                    operators.Add(SlidingPuzzleSolver.LEFT);
                }
                if (puzzle.CanMoveRight(puzzle.GapPosition))
                {
                    operators.Add(SlidingPuzzleSolver.RIGHT);
                }

                return(operators);
            }
Example #2
0
            // Devuelve los operadores aplicables a una determinada configuración del problema
            // Se devuelve HashSet porque es un conjunto sin orden, aunque también se podría haber decidido devolver una lista
            public HashSet <Operator> GetApplicableOperators(object setup)
            {
                if (setup == null || !(setup is SlidingPuzzle))
                {
                    throw new ArgumentException("Setup is not a valid SlidingPuzzle");
                }

                // Lo que recibe es un SlidingPuzzle
                SlidingPuzzle puzzle = (SlidingPuzzle)setup;

                HashSet <Operator> operators = new HashSet <Operator>();

                if (puzzle.CanMoveUp(puzzle.GapPosition))
                {
                    operators.Add(SlidingPuzzleSolver.UP);
                }
                if (puzzle.CanMoveDown(puzzle.GapPosition))
                {
                    operators.Add(SlidingPuzzleSolver.DOWN);
                }
                if (puzzle.CanMoveLeft(puzzle.GapPosition))
                {
                    operators.Add(SlidingPuzzleSolver.LEFT);
                }
                if (puzzle.CanMoveRight(puzzle.GapPosition))
                {
                    operators.Add(SlidingPuzzleSolver.RIGHT);
                }

                return(operators);
            }
            public object GetResult(object setup, Operator op)
            {
                // Lo recibido es un puzle deslizante
                SlidingPuzzle puzzle = (SlidingPuzzle)setup;
                // Un puzle deslizante se puede clonar a nivel profundo
                SlidingPuzzle puzzleClone = puzzle.DeepClone();


                if (SlidingPuzzleSolver.UP.Equals(op))
                {
                    if (puzzleClone.CanMoveUp(puzzleClone.GapPosition))
                    {
                        puzzleClone.MoveUp(puzzleClone.GapPosition);
                    }
                    else // No puede ocurrir que el operador aplicable no funcione, porque ya se comprobó que era aplicable
                    {
                        throw new InvalidOperationException("This operator is not working propertly");
                    }
                }

                if (SlidingPuzzleSolver.DOWN.Equals(op))
                {
                    if (puzzleClone.CanMoveDown(puzzleClone.GapPosition))
                    {
                        puzzleClone.MoveDown(puzzleClone.GapPosition);
                    }
                    else // No puede ocurrir que el operador aplicable no funcione, porque ya se comprobó que era aplicable
                    {
                        throw new InvalidOperationException("This operator is not working propertly");
                    }
                }

                if (SlidingPuzzleSolver.LEFT.Equals(op))
                {
                    if (puzzleClone.CanMoveLeft(puzzleClone.GapPosition))
                    {
                        puzzleClone.MoveLeft(puzzleClone.GapPosition);
                    }
                    else // No puede ocurrir que el operador aplicable no funcione, porque ya se comprobó que era aplicable
                    {
                        throw new InvalidOperationException("This operator is not working propertly");
                    }
                }

                if (SlidingPuzzleSolver.RIGHT.Equals(op))
                {
                    if (puzzleClone.CanMoveRight(puzzleClone.GapPosition))
                    {
                        puzzleClone.MoveRight(puzzleClone.GapPosition);
                    }
                    else // No puede ocurrir que el operador aplicable no funcione, porque ya se comprobó que era aplicable
                    {
                        throw new InvalidOperationException("This operator is not working propertly");
                    }
                }

                // Si el operador no se reconoce o es un NoOp, se devolverá la configuración actual (que sería idéntica a la original, no ha habido cambios)
                return(puzzleClone);
            }