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;
}
public Evolve(pokemon_data Pokemon, string EvolutionMethod, UpdateAStarGameObject UpdateAStar, UpdateAStarTarget UpdateAStar2, PathFindAStar AStar)
{
pokemon = Pokemon;
evolutionMethod = EvolutionMethod;
updateAStar = UpdateAStar;
updateAStar2 = UpdateAStar2;
aStar = AStar;
}
public UpdateAStar(Stack <Kinetics> Pokemons, PathFindAStar AStar, Graph Graph, Kinetics KinAgent, string[] Walkable)
{
pokemons = Pokemons;
aStar = AStar;
graph = Graph;
kinAgent = KinAgent;
walkable = Walkable;
}
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;
}
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);
}
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);
}
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();
}
// 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);
}
public PokemonMoved(Stack <Kinetics> Pokemons, PathFindAStar AStar)
{
pokemons = Pokemons;
aStar = AStar;
}
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);
}
public PokemonInCoverPoint(PathFindAStar AStar, SightSensor Sensor, Transform Character)
{
aStar = AStar;
sensor = Sensor;
character = Character;
}