Exemple #1
0
        //PlayRandom va a obtener las posibles operaciones a realizar (movimientos o limpieza)
        //aleatoriamente va a ejecutar una
        //Si es un movimiento y el robot carga un niño, puede aleatoriamente volver a ejecutar
        //un movimiento o no hacer nada.
        public override void Play()
        {
            var carrying  = IsCarryingChild();
            var adjacents = Environment.AdjacentCells(CurrentPos,
                                                      p => !Environment[p].IsObstacled() &&
                                                      (!Environment[p].IsChild() || !IsCarryingChild()) &&
                                                      (!Environment[CurrentPos].IsPlaypen() || !IsCarryingChild() || Environment[p].IsPlaypen()));

            if (adjacents.Count == 0)
            {
                adjacents = Environment.AdjacentCells(CurrentPos,
                                                      p => !Environment[p].IsObstacled() &&
                                                      (!Environment[p].IsChild() || !IsCarryingChild()));
            }

            //Si hay otro lugar a donde ir que no regrese al punto anterior
            if (adjacents.Count > 1)
            {
                adjacents.RemoveWhere(x => x.Item2 == PreviousPos);
            }

            var opers = AllowedOperations(adjacents);

            if (opers == null || opers.Count == 0)
            {
                return;
            }

            ExecuteRandomOperation(opers, adjacents);

            if (carrying && IsCarryingChild())
            {
                adjacents = Environment.AdjacentCells(CurrentPos,
                                                      p => (PreviousPos != p) &&
                                                      !Environment[p].IsObstacled() &&
                                                      (!Environment[p].IsChild() || !IsCarryingChild()) &&
                                                      (!Environment[CurrentPos].IsPlaypen() || !IsCarryingChild() || Environment[p].IsPlaypen()));

                opers = AllowedOperations(adjacents);

                if (opers == null || opers.Count == 0)
                {
                    return;
                }

                ExecuteRandomOperation(opers, adjacents);
            }
            isMoving = false;
        }
        //PlayCleaningFirst prioriza la limpieza antes que el movimiento
        //Obtiene las posibles operaciones a realizar que prioricen la limpieza: limpiar si la
        //casilla está sucia y moverse a una casilla sucia. Si no hay casillas sucias alrededor
        //del robot y carga un niño, debe moverse a la que más vecinas sucias tenga
        public override void Play()
        {
            if (Environment[CurrentPos].IsDirty())
            {
                Clean();
            }
            else
            {
                //Si el robot está en el corral y soltó al niño, salir del corral
                var adjacents = Environment.AdjacentCells(CurrentPos, p => Environment[CurrentPos].IsChild() &&
                                                          Environment[CurrentPos].IsPlaypen() &&
                                                          !Environment[p].IsPlaypen() &&
                                                          !Environment[p].IsObstacled());
                if (adjacents.Count > 0)
                {
                    RandomMove(adjacents);
                }
                else
                {
                    adjacents = Environment.AdjacentCells(CurrentPos, p => Environment[p].IsEmpty() && Environment[p].IsPlaypen());

                    if (IsCarryingChild() && adjacents.Count > 0)
                    {
                        RandomMove(adjacents);
                    }
                    else
                    {
                        adjacents = Environment.AdjacentCells(CurrentPos,
                                                              p => Environment[p].IsDirty());

                        if (adjacents.Count > 0)
                        {
                            RandomMove(adjacents);
                        }
                        else
                        //Si no hay ninguna casilla adyacente sucia
                        //se verifica si en el próximo paso puede caer en una casilla sucia
                        {
                            //
                            var carrying = IsCarryingChild();
                            //Obtener las casillas adyacentes hacia donde se puede mover
                            adjacents = Environment.AdjacentCells(CurrentPos,
                                                                  p => !Environment[p].IsObstacled() &&
                                                                  (!Environment[p].IsChild() || !IsCarryingChild()) &&
                                                                  (!Environment[CurrentPos].IsPlaypen() || !IsCarryingChild() || Environment[p].IsPlaypen()));

                            var adjacentsArray = adjacents.ToArray <Tuple <MovementDirection, Point> >();

                            var dirtyNeighbors = new HashSet <Tuple <MovementDirection, Point> > [adjacentsArray.Length];

                            var maxDirt  = 0;
                            var maxIndex = -1;

                            //Busca las casillas sucias alrededor de cada una de las casillas adyacentes
                            for (var i = 0; i < adjacentsArray.Length; i++)
                            {
                                var dirtyAdjacents = Environment.AdjacentCells(adjacentsArray[i].Item2,
                                                                               p => Environment[p].IsDirty());
                                dirtyNeighbors[i] = dirtyAdjacents;
                                if (dirtyNeighbors[i].Count > maxDirt)
                                {
                                    maxDirt  = dirtyNeighbors[i].Count;
                                    maxIndex = i;
                                }
                            }

                            if (maxDirt > 0)
                            {
                                MoveTo(adjacentsArray[maxIndex].Item2); //Moverse a la casilla que tiene más vecinas sucias
                                MovementCount++;
                                if (carrying && IsCarryingChild())
                                {
                                    RandomMove(dirtyNeighbors[maxIndex], null); //Moverse aleatoriamente a una de las casillas sucias
                                }
                            }
                            else
                            {
                                //Si no había vecinas sucias para ninguno de los posibles movimientos
                                //se mueve aleatoriamente, vuelve a obtener los posibles movimientos
                                //y se vuelve a mover aleatoriamente excluyendo la posición de la que partió
                                RandomMove(adjacents, null);
                                if (carrying && IsCarryingChild())
                                {
                                    adjacents = Environment.AdjacentCells(CurrentPos, p => (p != PreviousPos) &&
                                                                          !Environment[p].IsObstacled() &&
                                                                          (!Environment[p].IsChild() || !IsCarryingChild()) &&
                                                                          (!Environment[CurrentPos].IsPlaypen() || !IsCarryingChild() || Environment[p].IsPlaypen()));
                                    RandomMove(adjacents, null);
                                }
                            }
                        }
                    }
                }
            }
        }
Exemple #3
0
        //Jugada del niño en la que escoge hacia dónde se mueve y ejecuta el movimiento
        public void Play()
        {
            //Si está cargado o en el corral no puede moverse
            if ((Status == ChildStatus.Carried) || (Status == ChildStatus.Penned))
            {
                return;
            }

            if (Playing != null)
            {
                Playing(this, null);
            }

            //Direcciones hacia donde se puede mover
            var adjacents = Environment.AdjacentCells(CurrentPos, p =>
                                                      !Environment[p].IsPlaypen() &&
                                                      (Environment[p].IsEmpty() ||
                                                       Environment[p].IsObstacled()));
            int n;

            if (adjacents.Count == 0)
            {
                return;
            }
            n = randomMov.Next();
            if (adjacents.Count <= n)
            {
                return;
            }

            //Escoger aleatoriamente una dirección
            var tuple = adjacents.ToArray <Tuple <MovementDirection, Point> >()[n];

            var moved = MoveTo(tuple.Item2, p => !Environment[p].IsObstacled() || PushObstacle(p, tuple.Item1));

            if (!moved)
            {
                return;
            }

            //Obtener la cuadrícula de la posición anterior
            var grid = Environment.Grid(PreviousPos);

            //Obtener el número de niños dentro de la cuadrícula
            var ch = Environment.ChildrenInGrid(grid);

            //Eliminar las casillas que no están limpias
            grid = Environment.CleanGrid(grid);

            //Obtener el número máximo de suciedad que puede ser generada
            //dependiendo de la cantidad de casillas vacías y de niños
            var dirt = Math.Min(grid.Count, ch <= 3 ? Environment.dirtPerGrid[ch] : Environment.dirtPerGrid[3]);

            //Generar aleatoriamente de 0-dirt casillas sucias
            Environment.GenDirt(dirt, grid);

            if (Played != null)
            {
                Played(this, null);
            }
        }