void guess_and_move()
{
/*==========================Guess and move===========================
* According to the player's move, the robot will guess
* which evador the player is targeting, and also move towards
* that evador.
* Right now I suggest players are targeting the Evador _e when:
* - they keep shortening the manhattan distance between _e and themselves;
* - if there are multiple, choose the closest one.
* - I suppose evador are always running to exit,from the robot's propose.
* =========================Guess and move==============================*/
if (player_target.Count == 0)
{
create_target_list();
}
refresh_target_list();
evador_behave target_evador = Find_target(player_target);
grid_node exit_node = sg.nodes.Find(x => x.state == SquareGrid.grid_stat.exit);
grid_node target_grid = next_closest_to_target(target_evador.current_node, exit_node);
target_grid.SendMessage("flash_me");
grid_node candidate = next_closest_to_target(current_node, target_grid);
if (candidate != null)
{
move_to_grid(sg, candidate);
}
}
void create_target_list()
{
player_target.Clear();
GameObject[] target_evadors = GameObject.FindGameObjectsWithTag("evador");
foreach (GameObject _e in target_evadors)
{
evador_behave eb = _e.GetComponent <evador_behave>();
player_target.Add(eb);
previous_step[eb] = 0;
current_step[eb] = 0;
rf_factor[eb] = 1;
}
}
// Update is called once per frame
//========================simple state machine=======================================
void corner_target(evador_behave target)
{
if (target == null)
{
Debug.LogWarning("No target to be corner.");
block_exit();
return;
}
else
{
deploy_my_bots(target.current_node);
}
}
bool cornered(evador_behave eb)
{
/*=========================================================
* 1st: all neighbours are occupied;
* 2nd: they are occupied either by a player or a robot;
* =========================================================*/
foreach (grid_node n in GridsGenerator.instance.g.my_neighbours(eb.current_node))
{
if (n.occupied == false)
{
Debug.LogWarning("some of my nbs is empty."); return(false);
}
else if (n.gameObject.transform.GetChild(0).tag == "evador")
{
return(false);
}
}
return(true);
}
public void update_state(robot_state r, evador_behave target = null)
{
//robots current positions
switch (r)
{
case robot_state.defeat:
corner_target(target);
return;
case robot_state.cooperate:
if (player_target.Count == 0)
{
create_target_list();
}
refresh_target_list();
evador_behave target_evador = Find_target(player_target);
corner_target(target_evador);
return;
}
//target
}
evador_behave Find_target(List <evador_behave> t)
{
int min_reward = 0;
int reward;
evador_behave target_now = null;
foreach (evador_behave eb in t)
{
reward = 0;
if ((int)previous_step[eb] >= current_step[eb])
{
reward = -30 * rf_factor[eb];
rf_factor[eb] += 1;
}
else
{
rf_factor[eb] = 1;
} //clear target threat;
reward += Manhattan(current_node.grid_position, eb.current_node.grid_position);
if (target_now == null)
{
target_now = eb;
min_reward = reward;
}
else
{
target_now = reward < min_reward?eb:target_now;
}
}
if (target_now)
{
target_now.SendMessage("flash_me");
}
return(target_now);
}
void Update()
{
//manually update the stages.
if (Input.GetKeyDown(KeyCode.Space))
{
Stage_switch();
}
switch (current_stage)
{
case stage.Player_moving:
GameObject[] ev_instance = GameObject.FindGameObjectsWithTag("evador");
if (ev_instance.Length == 0)
{
//NNprocessor.instance.update_weights(NNprocessor.instance.current_index,(float)score_evador);
NNprocessor.instance.print_results();
Application.LoadLevel(0);
}
GridsGenerator.instance.player_instance.SendMessage("move");
return;
case stage.Robot_moving:
//this will be controlled all together
//so I will change this one to a robot-controller.
if (!stage_processed)
{
stage_processed = true;
/*
* GameObject[] robot_instance=GameObject.FindGameObjectsWithTag("robot");
* foreach(GameObject rb in robot_instance)
* rb.SendMessage("guess_and_move");
*
* StartCoroutine("stage_yield");*/
GameObject[] evador_instance = GameObject.FindGameObjectsWithTag("evador");
evador_behave target = target_list[NNprocessor.instance.order_index[NNprocessor.instance.current_index][index_in_list]];
if (!target)
{
index_in_list++;
}
Robots_controller.instance.update_state(Robots_controller.robot_state.defeat, target);
// Robots_controller.instance.update_state(Robots_controller.robot_state.cooperate);
if (target)
{
target.SendMessage("flash_me");
}
}
return;
case stage.Evador_moving:
//Add more protection method for time-consumption for computing
if (!stage_processed)
{
stage_processed = true;
GameObject[] evador_instance = GameObject.FindGameObjectsWithTag("evador");
foreach (GameObject ev in evador_instance)
{
evador_behave eb = ev.GetComponent <evador_behave>();
if (cornered(eb))
{
Debug.Log("I am cornerd");
eb.SendMessage("explode", Color.red);
eb.current_node.occupied = false;
DestroyImmediate(eb.gameObject);
}
}
foreach (GameObject ev in evador_instance)
{
if (ev)
{
ev.SendMessage("IQ2_move");
}
}
//modify this to change method
StartCoroutine("stage_yield");
}
return;
default:
return;
}
}
