Esempio n. 1
0
    PathFindAStar aStar;                   //para lo mismo que updateAstar


    public Evolve2(pokemon_data Pokemon, TouchedGameObjects TouchedStone, UpdateAstarBestCoverPoint UpdateAStar, PathFindAStar AStar)
    {
        pokemon      = Pokemon;
        touchedStone = TouchedStone;
        updateAStar  = UpdateAStar;
        aStar        = AStar;
    }
 public UpdateAStarTarget(PathFindAStar AStar, Graph Graph, Kinetics KinAgent, Node Target, string[] Walkable)
 {
     aStar     = AStar;
     graph     = Graph;
     kinAgent  = KinAgent;
     newTarget = Target;
     walkable  = Walkable;
 }
    public ArrivedToPosition arrived;//condicion que tenemos que actualizar tambien

    public UpdateAStarRandom(PathFindAStar AStar, Graph Graph, Kinetics KinAgent, ArrivedToPosition Arrived, string[] Walkable)
    {
        aStar    = AStar;
        graph    = Graph;
        kinAgent = KinAgent;
        arrived  = Arrived;
        walkable = Walkable;
    }
 public UpdateAStarSeenStone(SightSensor Sensor, PathFindAStar AStar, Graph Graph, Transform Character, string[] Walkable)
 {
     sensor    = Sensor;
     aStar     = AStar;
     graph     = Graph;
     character = Character;
     walkable  = Walkable;
 }
 public UpdateAStarGameObject(Stack <GameObject> Items, PathFindAStar AStar, Graph Graph, Kinetics KinAgent, string[] Walkable)
 {
     items    = Items;
     aStar    = AStar;
     graph    = Graph;
     kinAgent = KinAgent;
     walkable = Walkable;
 }
Esempio n. 6
0
 public Evolve(pokemon_data Pokemon, string EvolutionMethod, UpdateAStarGameObject UpdateAStar, UpdateAStarTarget UpdateAStar2, PathFindAStar AStar)
 {
     pokemon         = Pokemon;
     evolutionMethod = EvolutionMethod;
     updateAStar     = UpdateAStar;
     updateAStar2    = UpdateAStar2;
     aStar           = AStar;
 }
Esempio n. 7
0
 public UpdateAStar(Stack <Kinetics> Pokemons, PathFindAStar AStar, Graph Graph, Kinetics KinAgent, string[] Walkable)
 {
     pokemons = Pokemons;
     aStar    = AStar;
     graph    = Graph;
     kinAgent = KinAgent;
     walkable = Walkable;
 }
Esempio n. 8
0
    public string[] walkable; //nodos sobre los que puede caminar el personaje

    public UpdateAstarBestCoverPoint(List <CoverNode> CoverPoints, Transform Character, Transform[] Enemies, obstacle_data[] Obstacles, Graph Graph, PathFindAStar Astar, string[] Walkable)
    {
        coverPoints = CoverPoints;
        character   = Character;
        enemies     = Enemies;
        obstacles   = Obstacles;
        graph       = Graph;
        aStar       = Astar;
        walkable    = Walkable;
    }
Esempio n. 9
0
    void Start()
    {
        //POKEMONES
        pokemons = GameObject.FindGameObjectsWithTag("Pokemon");

        for (int i = 0; i < pokemons.Length; i++)//le sacamos todos los kinetics a los pokes
        {
            kinsList.Add(pokemons[i].GetComponent <static_data>().kineticsAgent);
        }

        pokemonKins   = kinsList.ToArray();
        amountPokemon = pokemons.Length;

        //TRAINER
        kineticsAgent = agent.kineticsAgent;
        steeringAgent = agent.steeringAgent;


        //Inicializamos movimiento (no es necesario pasar el pokemon porque lo haremos por posicion)
        seek = new Seek(kineticsAgent, kineticsAgent, maxAccel);

        //Inicializamos grafo y A*


        graph           = graphComponent.graph;
        pokemonPosition = pokemonKins[0].transform.position;

        walkable = new string[] { "Earth" };                       //sobre que podemos movernos

        Node start = graph.FindNode(transform.position, walkable); //buscamos el triangulos con nuestra posicion actual
        Node goal  = graph.FindNode(pokemonPosition, walkable);    //buscamos el triangulo donde esta el primer pokemon

        if (goal is null)                                          //si no hay un triangulo para el goal vamos a donde estamos parados
        {
            goal = start;
        }
        Euclidean euclidean = new Euclidean(goal);

        aStar         = new PathFindAStar(graph, start, goal, euclidean, walkable);
        currentPath   = aStar.GetPath();
        currentTarget = currentPath[0];
        utilities.DrawPath(currentPath, 40f);
    }
    public Transform[] allEevees;   //necesitamos saber donde estan todos los eevee


    void Start()
    {
        //INICIALIZAMOS LA DATA DEL EXTERIOR
        kineticsAgent   = agent.kineticsAgent;
        steeringAgent   = agent.steeringAgent;
        kineticsTrainer = trainer.kineticsAgent;
        kineticsRival   = rival.kineticsAgent;

        Vector3 center = Vector3.zero;// Necesitamos el centro de masa de los eevee

        for (int k = 0; k < allEevees.Length; k++)
        {
            center += allEevees[k].transform.position;
        }

        center = center / allEevees.Length; // Centro de masas

        //piedras
        stones = GameObject.FindGameObjectsWithTag("Stone");


        Stack <GameObject> stonesStack = new Stack <GameObject>(stones);


        //Inicializamos grafo y A*
        graph = graphComponent.graph;
        aStar = new PathFindAStar(graph, null, null, null, walkable);

        //Inicializamos seek
        seek = new Seek(kineticsAgent, kineticsAgent, maxAccel);

        //obstaculos
        GameObject[]    obstacles     = GameObject.FindGameObjectsWithTag("Obstacle");
        obstacle_data[] obstaclesData = new obstacle_data[obstacles.Length];

        for (int k = 0; k < obstacles.Length; k++)
        {
            obstaclesData[k] = obstacles[k].GetComponent <obstacle_data>();
        }



        //COMENZAMOS A CONSTRUIR LA MAQUINA DE ESTADOS

        //1. ACCIONES:

        UpdateAStarGameObject     updateAStar  = new UpdateAStarGameObject(stonesStack, aStar, graph, kineticsAgent, walkable);
        FollowPathOfPoints        followPath   = new FollowPathOfPoints(steeringAgent, seek, null, false);
        PopGameObject             popStone     = new PopGameObject(stonesStack);
        DestroyGameObject         destroyStone = new DestroyGameObject(stonesStack);
        UpdateFollowPathWithAstar updateFollow = new UpdateFollowPathWithAstar(followPath, aStar, obstaclesData);
        UpdateAStarTarget         updateAStar2 = new UpdateAStarTarget(aStar, graph, kineticsAgent, graph.GetNode(550), walkable);
        StopMoving         stop               = new StopMoving(kineticsAgent, steeringAgent);
        RunSprite          showRunSprite      = new RunSprite(pokemonData);
        Evolve             evolve             = new Evolve(pokemonData, "Sun", updateAStar, updateAStar2, aStar);
        updateEvolveMethod updateEvolve       = new updateEvolveMethod(evolve, stonesStack);
        ShowIcon           showExclamation    = new ShowIcon(this.gameObject, "Exclamation");
        DisableIcon        disableExclamation = new DisableIcon(this.gameObject, "Exclamation");
        ShowIcon           showSweat          = new ShowIcon(this.gameObject, "Sweat");
        DisableIcon        disableSweat       = new DisableIcon(this.gameObject, "Sweat");



        //2. ESTADOS:

        List <Action> entryActions; //aqui iremos guardanndo todas las acciondes de entrada
        List <Action> exitActions;  //aqui iremos guardanndo todas las acciones de salida
        List <Action> actions;      //aqui guardaremos todas las acciones intermedias

        //2.a estado para esperar sin hacer nada
        entryActions = new List <Action>()
        {
            stop
        };                                       //al entrar al estado debemos parar
        actions     = new List <Action>();
        exitActions = new List <Action>();

        State wait = new State(actions, entryActions, exitActions);


        //2.b estado para sorprenderse
        entryActions = new List <Action>()
        {
            showExclamation
        };                                                  //al entrar al estado debemos sorprendernos
        actions     = new List <Action>();
        exitActions = new List <Action>()
        {
            disableExclamation
        };                                                   //al salir dejamos de sorprendernos

        State alert = new State(actions, entryActions, exitActions);

        //2.c estado para perseguir piedra
        entryActions = new List <Action>()
        {
            updateAStar, updateFollow, showSweat
        };                                                                       //al entrar al estado debemos actualizar el a* y luego el camino
        actions = new List <Action>()
        {
            followPath
        };                                 //durante la accion seguimos el camino
        exitActions = new List <Action>(); //al salir no hacemos nada

        State followStone = new State(actions, entryActions, exitActions);

        //2.d estado para perseguir punto de encuentro
        entryActions = new List <Action>()
        {
            updateAStar2, updateFollow
        };                                                             //al entrar al estado debemos actualizar el a* y luego el camino
        actions = new List <Action>()
        {
            followPath
        };                                 //durante la accion seguimos el camino
        exitActions = new List <Action>(); //al salir no hacemos nada

        State followReunionPoint = new State(actions, entryActions, exitActions);

        //3. CONDICIONES:

        TooCloseToPoint closeTrainer     = new TooCloseToPoint(center, kineticsTrainer, radiusAlert);
        TooCloseToPoint veryCloseTrainer = new TooCloseToPoint(center, kineticsTrainer, radiusRun);
        TooCloseToPoint closeRival       = new TooCloseToPoint(center, kineticsRival, radiusAlert);
        TooCloseToPoint veryCloseRival   = new TooCloseToPoint(center, kineticsRival, radiusRun);

        //Estas son las que de verdad necesitamos
        OrCondition  anyTargetClose     = new OrCondition(closeTrainer, closeRival);
        OrCondition  anyTargetVeryClose = new OrCondition(veryCloseRival, veryCloseTrainer);
        NotCondition noOneClose         = new NotCondition(anyTargetClose);
        NotCondition noOneVeryClose     = new NotCondition(anyTargetVeryClose);

        GameObjectGone    stoneGone      = new GameObjectGone(stonesStack);                //si una piedra es obtenida por alguien mas
        AllGameObjectGone allStoneGone   = new AllGameObjectGone(stonesStack);             //si se acaban las piedras
        ArrivedToStone    arrivedToStone = new ArrivedToStone(stonesStack, transform, 2f); //si alcanzamos una piedra



        //4. TRANSICIONES:

        Transition closeHuman     = new Transition(anyTargetClose, new List <Action>(), alert);
        Transition noHumanClose   = new Transition(noOneClose, new List <Action>(), wait);
        Transition veryCloseHuman = new Transition(anyTargetVeryClose, new List <Action>()
        {
            showRunSprite
        }, followStone);
        Transition stoneLost = new Transition(stoneGone, new List <Action> {
            popStone
        }, followStone);
        Transition allStonesLost = new Transition(allStoneGone, new List <Action> {
            evolve, disableSweat
        }, followReunionPoint);
        Transition reachStone = new Transition(arrivedToStone, new List <Action> {
            updateEvolve, evolve, destroyStone, popStone, disableSweat
        }, followReunionPoint);



        //4.1 AGREGAMOS TRANSICIONES A ESTADOS

        List <Transition> transitions;

        transitions = new List <Transition>()
        {
            closeHuman
        };
        wait.transitions = transitions;

        transitions = new List <Transition>()
        {
            veryCloseHuman, noHumanClose
        };
        alert.transitions = transitions;

        transitions = new List <Transition>()
        {
            allStonesLost, stoneLost, reachStone
        };
        followStone.transitions = transitions;

        followReunionPoint.transitions = new List <Transition>();



        //5 MAQUINA DE ESTADOS
        State[] states = new State[] { wait, alert, followStone, followReunionPoint };
        eeveeMachine = new StateMachine(states, wait);
    }
Esempio n. 11
0
    void Start()
    {
        //INICIALIZAMOS LA DATA DEL EXTERIOR
        kinDugtrio      = dugtrio.kineticsAgent;
        steeringDugtrio = dugtrio.steeringAgent;
        kineticsTrainer = trainer.kineticsAgent;
        kineticsRival   = rival.kineticsAgent;
        graph           = graphComponent.graph;
        aStar           = new PathFindAStar(graph, null, null, null, walkable);
        seek            = new Seek(kinDugtrio, kinDugtrio, dugtrio.maxspeed);

        Kinetics[] targets = new Kinetics[2];
        targets[0] = kineticsTrainer;
        targets[1] = kineticsRival;

        //obstaculos
        GameObject[]    obstacles     = GameObject.FindGameObjectsWithTag("Obstacle");
        obstacle_data[] obstaclesData = new obstacle_data[obstacles.Length];

        for (int k = 0; k < obstacles.Length; k++)
        {
            obstaclesData[k] = obstacles[k].GetComponent <obstacle_data>();
        }

        //COMENZAMOS A CONSTRUIR LA MAQUINA DE ESTADOS

        //1. ACCIONES:

        UpdateAStarRandom         updateAStar  = new UpdateAStarRandom(aStar, graph, kinDugtrio, null, walkable);
        ShowIcon                  showHole     = new ShowIcon(this.gameObject, "Digging");
        DisableIcon               disableHole  = new DisableIcon(this.gameObject, "Digging");
        FollowPathOfPoints        followPath   = new FollowPathOfPoints(steeringDugtrio, seek, null, true);
        UpdateFollowPathWithAstar updateFollow = new UpdateFollowPathWithAstar(followPath, aStar, obstaclesData);
        MoveOnZ underground    = new MoveOnZ(transform, undergroundCoord);
        MoveOnZ getOutOfGround = new MoveOnZ(transform, 0f);

        //2. ESTADOS:

        List <Action> entryActions; //aqui iremos guardanndo todas las acciondes de entrada
        List <Action> exitActions;  //aqui iremos guardanndo todas las acciones de salida
        List <Action> actions;      //aqui guardaremos todas las acciones intermedias

        //2.a estado para seguir camino

        entryActions = new List <Action>()
        {
        };
        actions = new List <Action>()
        {
            followPath
        };                                       //durante el estado seguimos el camino
        exitActions = new List <Action>()
        {
        };

        State followPathState = new State(actions, entryActions, exitActions);

        //3. CONDICIONES:

        TooClose          closeTrainer   = new TooClose(kinDugtrio, kineticsTrainer, radiusHide);
        TooClose          closeRival     = new TooClose(kinDugtrio, kineticsRival, radiusHide);
        ArrivedToPosition arrived        = new ArrivedToPosition(new Vector3(), transform, 10f);
        AmIUnderground    amIunderground = new AmIUnderground(transform);

        updateAStar.arrived = arrived;

        OrCondition  anyTargetClose        = new OrCondition(closeTrainer, closeRival);
        NotCondition noOneClose            = new NotCondition(anyTargetClose);
        NotCondition notUnderground        = new NotCondition(amIunderground);
        AndCondition closeAndNotUndeground = new AndCondition(anyTargetClose, notUnderground);
        AndCondition notCloseAndUndeground = new AndCondition(noOneClose, amIunderground);


        List <Action> noActions = new List <Action>();
        List <Action> transitionActions;

        //4. TRANSICIONES:
        transitionActions = new List <Action>()
        {
            showHole, underground
        };
        Transition anyHumanClose = new Transition(closeAndNotUndeground, transitionActions, followPathState);

        transitionActions = new List <Action>()
        {
            disableHole, getOutOfGround
        };
        Transition noHumanClose = new Transition(notCloseAndUndeground, transitionActions, followPathState);

        transitionActions = new List <Action>()
        {
            updateAStar, updateFollow
        };
        Transition pathEnd = new Transition(arrived, transitionActions, followPathState);



        //4.1 AGREGAMOS TRANSICIONES A ESTADOS
        List <Transition> transitions = new List <Transition>()
        {
            anyHumanClose, noHumanClose, pathEnd
        };

        followPathState.transitions = transitions;


        //5 MAQUINA DE ESTADOS
        State[] states = new State[] { followPathState };
        dugtrioMachine = new StateMachine(states, followPathState);
        updateAStar.DoAction();//esto es para inicializar el primer camino
        updateFollow.DoAction();
    }
 public UpdateFollowPathWithAstar(FollowPathOfPoints Follow, PathFindAStar AStar, obstacle_data[] obstacles)
 {
     follow     = Follow;
     aStar      = AStar;
     smoothPath = new SmoothPath(obstacles);
 }
Esempio n. 13
0
    void Start()
    {
        //INICIALIZAMOS LA DATA DEL EXTERIOR
        kinJigglypuff      = jigglypuff.kineticsAgent;
        steeringJigglypuff = jigglypuff.steeringAgent;

        graph = graphComponent.graph;
        aStar = new PathFindAStar(graph, null, null, null, walkable);
        seek  = new Seek(kinJigglypuff, kinJigglypuff, jigglypuff.maxspeed);


        //obstaculos
        GameObject[]    obstacles     = GameObject.FindGameObjectsWithTag("Obstacle");
        obstacle_data[] obstaclesData = new obstacle_data[obstacles.Length];

        for (int k = 0; k < obstacles.Length; k++)
        {
            obstaclesData[k] = obstacles[k].GetComponent <obstacle_data>();
        }

        //COMENZAMOS A CONSTRUIR LA MAQUINA DE ESTADOS

        //1. ACCIONES:

        UpdateAStarRandom         updateAStar      = new UpdateAStarRandom(aStar, graph, kinJigglypuff, null, walkable);
        FollowPathOfPoints        followPath       = new FollowPathOfPoints(steeringJigglypuff, seek, null, false);
        UpdateFollowPathWithAstar updateFollow     = new UpdateFollowPathWithAstar(followPath, aStar, obstaclesData);
        ShowFlySprite             showFlySprite    = new ShowFlySprite(jigglypuffData);
        ShowDefaultSprite         showDefaultSprie = new ShowDefaultSprite(jigglypuffData);
        EnableSendSound           enableSound      = new EnableSendSound(soundComp);
        DisableSendSound          disableSound     = new DisableSendSound(soundComp);


        //2. ESTADOS:

        List <Action> entryActions; //aqui iremos guardanndo todas las acciondes de entrada
        List <Action> exitActions;  //aqui iremos guardanndo todas las acciones de salida
        List <Action> actions;      //aqui guardaremos todas las acciones intermedias

        //2.a estado para seguir camino

        entryActions = new List <Action>()
        {
        };                                   //al entrar al estado ponemos un corazon
        actions = new List <Action>()
        {
            followPath
        };                                       //durante el estado perseguimos al enamorado
        exitActions = new List <Action>()
        {
        };                                 //al salir quitamos el corazon

        State followPathState = new State(actions, entryActions, exitActions);

        //3. CONDICIONES:

        ArrivedToPosition arrived = new ArrivedToPosition(new Vector3(), transform, 10f);

        updateAStar.arrived = arrived;

        TargetPointAir nextIsAir = new TargetPointAir(transform);

        TargetPointEarth nextIsEarth = new TargetPointEarth(transform);


        //4. TRANSICIONES:

        List <Action> noActions = new List <Action>();
        List <Action> transitionActions;


        transitionActions = new List <Action>()
        {
            updateAStar, updateFollow
        };
        Transition pathEnd = new Transition(arrived, transitionActions, followPathState);

        transitionActions = new List <Action>()
        {
            showFlySprite, disableSound
        };
        Transition toFly = new Transition(nextIsAir, transitionActions, followPathState);

        transitionActions = new List <Action>()
        {
            showDefaultSprie, enableSound
        };
        Transition toGround = new Transition(nextIsEarth, transitionActions, followPathState);



        //4.1 AGREGAMOS TRANSICIONES A ESTADOS
        List <Transition> transitions = new List <Transition>()
        {
            pathEnd, toFly, toGround
        };

        followPathState.transitions = transitions;


        //5 MAQUINA DE ESTADOS
        State[] states = new State[] { followPathState };
        jigglypuffMachine = new StateMachine(states, followPathState);
        updateAStar.DoAction();//esto es para inicializar el primer camino
        updateFollow.DoAction();
    }
Esempio n. 14
0
    // public float radiusAlert = 40f;//radio para alertarse
    // public float radiusRun = 35f;//radio para huir


    void Start()
    {
        //INICIALIZAMOS LA DATA DEL EXTERIOR
        kineticsAgent      = agent.kineticsAgent;
        steeringAgent      = agent.steeringAgent;
        kineticsTrainer    = trainer.kineticsAgent;
        kineticsRival      = rival.kineticsAgent;
        sightSensor        = sightComponent.sensor;
        sightSensorPokemon = sightComponentPokemon.sensor;
        soundSensor        = soundComponent.sensor;



        //Piedras
        stones = GameObject.FindGameObjectsWithTag("Stone");
        List <GameObject> stonesList = new List <GameObject>(stones);


        //Inicializamos grafo y A*
        graph = graphComponent.graph;
        aStar = new PathFindAStar(graph, null, null, null, walkable);

        //Inicializamos seek
        seek = new Seek(kineticsAgent, kineticsAgent, maxAccel);

        //Inicializamos lookwehereyougoing
        look = new LookWhereYouAreGoing(kineticsAgent);

        //Obstaculos
        GameObject[]    obstacles     = GameObject.FindGameObjectsWithTag("Obstacle");
        obstacle_data[] obstaclesData = new obstacle_data[obstacles.Length];

        for (int k = 0; k < obstacles.Length; k++)
        {
            obstaclesData[k] = obstacles[k].GetComponent <obstacle_data>();
        }

        //Puntos estrategicos
        strategicPoints = pointsComponent.coverNodes;



        //COMENZAMOS A CONSTRUIR LA MAQUINA DE ESTADOS

        //1. ACCIONES:

        //acciones relacionadas a astar
        FollowPathOfPoints        followPath       = new FollowPathOfPoints(steeringAgent, seek, null, false);
        UpdateFollowPathWithAstar updateFollow     = new UpdateFollowPathWithAstar(followPath, aStar, obstaclesData);
        UpdateAstarBestCoverPoint updateAstarCover = new UpdateAstarBestCoverPoint(strategicPoints, transform, new Transform[] { kineticsRival.transform, kineticsTrainer.transform }, obstaclesData, graph, aStar, walkable);
        UpdateAStarSeenStone      updateAstarStone = new UpdateAStarSeenStone(sightSensor, aStar, graph, transform, walkable);
        //acciones de manejo de giros
        SetAngularSpeed setDefaultRotation = new SetAngularSpeed(kineticsAgent, 10f);
        SetAngularSpeed setZeroRotation    = new SetAngularSpeed(kineticsAgent, 0f);
        StopMoving      stop       = new StopMoving(kineticsAgent, steeringAgent);
        LookWhereGoing  lookAction = new LookWhereGoing(look, steeringAgent);
        //acciones de manejo de srpites
        ShowDefaultSprite defaultSprite = new ShowDefaultSprite(pokemonData);
        RunSprite         showRunSprite = new RunSprite(pokemonData);
        Evolve2           evolve;
        ShowIcon          showExclamation    = new ShowIcon(this.gameObject, "Exclamation");
        DisableIcon       disableExclamation = new DisableIcon(this.gameObject, "Exclamation");
        ShowIcon          showSweat          = new ShowIcon(this.gameObject, "Sweat");
        DisableIcon       disableSweat       = new DisableIcon(this.gameObject, "Sweat");
        //acciones de asistencia
        ResetSensor     resetSight        = new ResetSensor(sightSensor);
        ResetSensor     resetSightPokemon = new ResetSensor(sightSensorPokemon);
        ResetSensor     resetSound        = new ResetSensor(soundSensor);
        ResetSensorList resetSensors      = new ResetSensorList(new List <ResetSensor>()
        {
            resetSight, resetSound, resetSightPokemon
        });
        //acciones de tiempo
        SetTimer setAlertTime;
        //acciones que modifican la maquina de estados misma
        RemoveStateTransition removeTouchStone;
        RemoveStateTransition removeSawStone;
        RemoveStateTransition removeSawStone2;
        RemoveAction          removeDefaultSpriteAction;
        RemoveAction          removeRunSpriteAction;
        RemoveAction          removeRunSpriteAction2;



        //2. ESTADOS:

        List <Action> entryActions; //aqui iremos guardanndo todas las acciondes de entrada
        List <Action> exitActions;  //aqui iremos guardanndo todas las acciones de salida
        List <Action> actions;      //aqui guardaremos todas las acciones intermedias

        //2.a estado para esperar sin hacer nada
        //durante este estado eevee estara quieto hasta que algun humano lo haga reaccionar
        entryActions = new List <Action>()
        {
            stop, defaultSprite, setZeroRotation, resetSensors
        };                                                                                     //al entrar al estado debemos parar y sentarnos
        removeDefaultSpriteAction = new RemoveAction(defaultSprite, entryActions);
        actions = new List <Action>()
        {
        };                            //hacer guardia girando
        exitActions = new List <Action>()
        {
        };

        State wait = new State(actions, entryActions, exitActions);


        //2.b estado para sorprenderse
        //durante este estado eevee dara vueltas en alterta angustiado porque escucho algo, este estado durara solo cierto tiempo
        entryActions = new List <Action>()
        {
            showExclamation, setDefaultRotation
        };                                                                      //al entrar al estado debemos sorprendernos
        actions = new List <Action>()
        {
        };
        exitActions = new List <Action>()
        {
            disableExclamation, setZeroRotation
        };                                                                    //al salir dejamos de sorprendernos

        State alert = new State(actions, entryActions, exitActions);

        //2.c estado para perseguir piedra
        //durante este estado eevee se concentrara unicamente en buscar las piedra que vio
        entryActions = new List <Action>()
        {
            updateAstarStone, updateFollow, showExclamation, showRunSprite
        };                                                                                                 //al entrar al estado debemos actualizar el a* y luego el camino
        removeRunSpriteAction2 = new RemoveAction(showRunSprite, entryActions);
        actions = new List <Action>()
        {
            followPath, lookAction
        };                                                   //durante la accion seguimos el camino
        exitActions = new List <Action>()
        {
            disableExclamation
        };                                                    //al salir no hacemos nada

        State followStone = new State(actions, entryActions, exitActions);

        //2.d estado para perseguir punto de encuentro
        //durante este estado eevee buscara donde esconderse, puede verse interrumpido si accidentalmente toca una piedra o se comprometio su escondite
        entryActions = new List <Action>()
        {
            updateAstarCover, updateFollow, showSweat, showRunSprite, resetSensors
        };                                                                                                         //al entrar al estado debemos actualizar el a* y luego el camino
        removeRunSpriteAction = new RemoveAction(showRunSprite, entryActions);
        actions = new List <Action>()
        {
            followPath, lookAction
        };                                                   //durante la accion seguimos el camino
        exitActions = new List <Action>()
        {
            disableSweat
        };                                              //al salir no hacemos nada

        State followCoverPoint = new State(actions, entryActions, exitActions);

        //2.extra dummy states
        //estos estados son de relleno para facilitar la activacion de ciertas acciones en le orden adecuado
        entryActions = new List <Action>(); //al entrar al estado debemos parar y sentarnos
        actions      = new List <Action>(); //hacer guardia girando
        exitActions  = new List <Action>(); //al salir no hacemos nada

        State evolveState1 = new State(actions, entryActions, exitActions);
        State evolveState2 = new State(actions, entryActions, exitActions);



        //3. CONDICIONES:

        SawSomething       sawStone            = new SawSomething(sightSensor, "Stone");               //si vemos una piedra evolutiva
        SawSomething       sawHuman            = new SawSomething(sightSensor, "Human");               //si vemos una persona
        HeardSomething     heardHumanClose     = new HeardSomething(soundSensor, "Human", 0f);         //si escuchamos a un humano cerca
        HeardSomething     heardHumanVeryClose = new HeardSomething(soundSensor, "Human", 5f);         //si escuchamos a un  humanos muy cerca
        TouchedGameObjects touchedStone        = new TouchedGameObjects(stonesList, transform, "Sun"); //si tocamos una piedra evolutiva

        evolve = new Evolve2(pokemonData, touchedStone, updateAstarCover, aStar);
        FollowArrived       arrived        = new FollowArrived(followPath, transform);                      //si llegamos al objetivo de follow
        PokemonInCoverPoint otherInMyCover = new PokemonInCoverPoint(aStar, sightSensorPokemon, transform); //si vemos que un pokemon se metio en nuestro escondite

        TimeOut alertTimeOut = new TimeOut(5f);

        setAlertTime = new SetTimer(alertTimeOut);
        TrueCondition alwaysTrue = new TrueCondition();


        //4. TRANSICIONES:

        List <Action> transitionsActions;
        List <Action> noActions = new List <Action>();

        transitionsActions = new List <Action>()
        {
            setAlertTime
        };
        Transition heardCloseHuman     = new Transition(heardHumanClose, transitionsActions, alert);
        Transition seemsSafe           = new Transition(alertTimeOut, noActions, wait);
        Transition heardVeryCloseHuman = new Transition(heardHumanVeryClose, noActions, followCoverPoint);

        transitionsActions = new List <Action>()
        {
        };
        Transition sawAhuman        = new Transition(sawHuman, transitionsActions, followCoverPoint);
        Transition sawAstone        = new Transition(sawStone, transitionsActions, followStone);
        Transition pokemonInMyCover = new Transition(otherInMyCover, transitionsActions, followCoverPoint);

        //transiciones dummy
        transitionsActions = new List <Action>()
        {
            evolve
        };
        Transition evolving1 = new Transition(alwaysTrue, transitionsActions, followCoverPoint);
        Transition evolving2 = new Transition(alwaysTrue, transitionsActions, wait);


        transitionsActions = new List <Action>()
        {
            evolve, removeDefaultSpriteAction, removeRunSpriteAction, removeRunSpriteAction2
        };
        Transition touchStone1 = new Transition(touchedStone, transitionsActions, evolveState1);
        Transition touchStone2 = new Transition(touchedStone, transitionsActions, evolveState2);

        //si evolucionamos debemos quitar las transiciones relacionadas a las stones
        removeSawStone   = new RemoveStateTransition(sawAstone, followCoverPoint);
        removeSawStone2  = new RemoveStateTransition(sawAstone, alert);
        removeTouchStone = new RemoveStateTransition(touchStone1, followCoverPoint);
        transitionsActions.Add(removeSawStone);
        transitionsActions.Add(removeSawStone2);
        transitionsActions.Add(removeTouchStone);

        Transition arrivedFollowEnd = new Transition(arrived, noActions, wait);

        //4.1 AGREGAMOS TRANSICIONES A ESTADOS

        List <Transition> transitions;

        transitions = new List <Transition>()
        {
            sawAhuman, heardCloseHuman
        };
        wait.transitions = transitions;

        transitions = new List <Transition>()
        {
            sawAhuman, sawAstone, heardVeryCloseHuman, seemsSafe
        };
        alert.transitions = transitions;

        transitions = new List <Transition>()
        {
            evolving1
        };
        evolveState1.transitions = transitions;

        transitions = new List <Transition>()
        {
            evolving2
        };
        evolveState2.transitions = transitions;


        transitions = new List <Transition>()
        {
            touchStone1, sawAstone, pokemonInMyCover, arrivedFollowEnd, sawAhuman
        };
        followCoverPoint.transitions = transitions;

        transitions = new List <Transition>()
        {
            touchStone2, arrivedFollowEnd, pokemonInMyCover
        };
        followStone.transitions = transitions;



        //5 MAQUINA DE ESTADOS
        State[] states = new State[] { wait, alert, followCoverPoint, followStone, evolveState1, evolveState2 };
        eeveeMachine = new StateMachine(states, wait);
    }
Esempio n. 15
0
 public PokemonMoved(Stack <Kinetics> Pokemons, PathFindAStar AStar)
 {
     pokemons = Pokemons;
     aStar    = AStar;
 }
Esempio n. 16
0
    void Start()
    {
        //INICIALIZAMOS LA DATA DEL EXTERIOR
        kineticsAgent = agent.kineticsAgent;
        steeringAgent = agent.steeringAgent;

        //POKEMONES
        pokemons = GameObject.FindGameObjectsWithTag("Pokemon");

        //barajeamos lo pokemones
        (new Utilities()).Shuffle(pokemons);

        pokemonKins = new Stack <Kinetics>();
        //creamos la pila de kinetics de los pokemones
        for (int i = 0; i < pokemons.Length; i++)
        {
            pokemonKins.Push(pokemons[i].GetComponent <static_data>().kineticsAgent);
        }

        //obstaculos
        GameObject[]    obstacles     = GameObject.FindGameObjectsWithTag("Obstacle");
        obstacle_data[] obstaclesData = new obstacle_data[obstacles.Length];

        for (int k = 0; k < obstacles.Length; k++)
        {
            obstaclesData[k] = obstacles[k].GetComponent <obstacle_data>();
        }

        //Inicializamos grafo y A*
        graph = graphComponent.graph;
        aStar = new PathFindAStar(graph, null, null, null, walkable);

        //Inicializamos seek
        seek = new Seek(kineticsAgent, kineticsAgent, maxAccel);

        //Inicializamos lookwehereyougoing
        look = new LookWhereYouAreGoing(kineticsAgent);


        //COMENZAMOS A CONSTRUIR LA MAQUINA DE ESTADOS

        //1. ACCIONES:

        UpdateAStar               updateAstar   = new UpdateAStar(pokemonKins, aStar, graph, kineticsAgent, walkable);
        FollowPathOfPoints        followPath    = new FollowPathOfPoints(steeringAgent, seek, null, false);
        RemovePokemon             removePokemon = new RemovePokemon(pokemonKins);
        UpdateFollowPathWithAstar updateFollow  = new UpdateFollowPathWithAstar(followPath, aStar, obstaclesData);
        StopMoving stop = new StopMoving(kineticsAgent, steeringAgent);

        //2. ESTADOS:

        List <Action> entryActions; //aqui iremos guardanndo todas las acciondes de entrada
        List <Action> exitActions;  //aqui iremos guardanndo todas las acciones de salida
        List <Action> actions;      //aqui guardaremos todas las acciones intermedias

        //2.a estado para seguir path

        entryActions = new List <Action>()
        {
            updateAstar, updateFollow
        };                                                            //al entrar al estado debemos
        //actualizar astar y el camino nuevo que da aStar darselo a follow
        actions = new List <Action>()
        {
            followPath
        };                                 //durante la accion seguimos el camino
        exitActions = new List <Action>(); //al salir no hacemos nada

        State followState = new State(actions, entryActions, exitActions);

        //2.b

        entryActions = new List <Action>()
        {
            stop
        };
        actions     = new List <Action>();
        exitActions = new List <Action>();

        State stopState = new State(actions, entryActions, exitActions);


        //3. CONDICIONES:

        AllCaught        allCaught            = new AllCaught(pokemonKins);           //ayudara a saber si todos los pokemon fueron atrpados
        CurrentWasCaught currentPokemonCaught = new CurrentWasCaught(pokemonKins);    //ayuda a saber si el pokemon actual en la pila fue atrapado
        PokemonMoved     pokemonMoved         = new PokemonMoved(pokemonKins, aStar); //ayudara a saber si el pokemon que estamos siguiendo se sale de su triangulo

        //4. TRANSICIONES:

        Transition caughtTarget = new Transition(currentPokemonCaught, new List <Action>()
        {
            removePokemon
        }, followState);
        Transition movedTarget      = new Transition(pokemonMoved, new List <Action>(), followState);
        Transition caughtAllTargets = new Transition(allCaught, new List <Action>(), stopState);

        //4.1 AGREGAMOS TRANSICIONES A ESTADOS

        List <Transition> transitions = new List <Transition>()
        {
            caughtAllTargets, caughtTarget, movedTarget
        };

        followState.transitions = transitions;

        stopState.transitions = new List <Transition>();

        //5 MAQUINA DE ESTADOS
        State[] states = new State[] { followState, stopState };
        rivalMachine = new StateMachine(states, followState);
    }
Esempio n. 17
0
 public PokemonInCoverPoint(PathFindAStar AStar, SightSensor Sensor, Transform Character)
 {
     aStar     = AStar;
     sensor    = Sensor;
     character = Character;
 }