using UnityEngine;using System.Coll

using UnityEngine;
using System.Collections.Generic;
using System;
using System.Collections;

public enum AntState
{
LOOKING_FOR_FOOD,
RETURNING_FOOD_TO_NEST,
/* To be Implmented
ATTACKING_ENEMY,
WARNING_ALLIES
*/
};

public class Ant : MonoBehaviour
{
//an ants actions depend on his current state
public AntState state { get; private set; }
public Vector3 position { get { return transform.position; } set { transform.position = value; } }
//a reference to the last pheromone. Used to set the direction of the next pheromone
public Pheromone last_placed_pheromone { get; set; }

//the final velocity of an ant is based on a random direction and influences from pheromones.
private Vector3 _velocity_random, _velocity_pheromone, _velocity_opposing;
//this is the actual velocity that the ant will use to move
public Vector3 velocity_final;

public NodeManager node_manager { private get; set; }
public Vector3 nest_position { private get; set; }
//random interval, so not all ants are updated at the same time.
private float _speed_random;
//the final speed the ant will use to move
private float _speed_final;
private bool _can_walk = true;

///
///the start function is a coroutine and functions as the update function.
///
IEnumerator Start( )
{
state = AntState.LOOKING_FOR_FOOD;
//all ants start at the nest.
position = nest_position.clone( );
//give a random element to the update time, so update times are spread
_speed_random = UnityEngine.Random.value * 2;

//set timers that will fire every so many seconds
float t_a = 7 / _speed_final, t_b = 51;
while ( true )
{
t_a += Time.deltaTime;

//the timer fires at different intervals, depending on the ant speed.
//this way, the rate of pheromone drops is equal, regardless of speed
if ( t_a >= 7 / _speed_final )
{
_speed_final = _speed_random + node_manager.gui_editor.get_ant_speed( );
node_manager.drop_pheromone( this );
//reset the pheromone drop timer
t_a = 0;
t_b++;
}
//if we are getting or delivering food we dont do anything this update
if ( !_can_walk )
{
//first, we are no longer unable to walk
_can_walk = true;
//wait for 2 seconds before going back to work.
yield return new WaitForSeconds( 2 );
}
//after 7 pheromones were dropped, move the ant in another direction.
if ( t_b >= node_manager.gui_editor.get_change_direction_rate( ) )
{
set_random_direction( );
//get a direction that is influenced by the pheromones in the vicinity
set_influence_from_pheromones( );
//Finally, set the velocity of the ant and make it move
StartCoroutine( calculate_velocity( ) );
//reset the counter so that the
t_b = 0;
}
//if we are at the edge of the grid (we have a collision with the 'walls' of the grid
if ( is_at_border( ) )
{
//reset the counter, so the ant doesnt change direction.
t_b = 0;
}
yield return null;
}
}

///
/// makes sure the ant doesn't walk out of the grid
///
bool is_at_border( )
{
foreach ( Plain p in node_manager.borders )
{
Vector3 ray;
if ( p.will_collide( this, NodeManager.node_size, out ray ) )
{
//make the ant walk in the opposite direction.
p.reflect_velocity( ref velocity_final, ray );
//make the ant move to the new location
StartCoroutine( move_to_new_location( position + velocity_final, 4 ) );
return true;
}
}
return false;
}

///
/// calculates the final velocity and then makes the ant move in that direction.
///
private IEnumerator calculate_velocity( )
{
update_velocity_smoothly( );
//then, we are moving towards that velocity over a period of 4 seconds
yield return StartCoroutine( move_to_new_location( position + velocity_final, 4 ) );
}

void OnTriggerEnter( Collider other )
{
switch( other.gameObject.tag )
{
//if we collided with the nest
case "nest":
// and we were looking for it
if ( state == AntState.RETURNING_FOOD_TO_NEST )
{
state = AntState.LOOKING_FOR_FOOD;
//we cannot walk for a short period of time (we are returning food)
_can_walk = false;
}
break;
//if we collided with food
case "food":
//and we are looking for food
if ( state == AntState.LOOKING_FOR_FOOD )
{
//since food can disappear after we ate it all, return if it is null
if ( other.gameObject == null ) return;
//otherwise, get the food component and tell it we are eating it
( other.gameObject.GetComponent( typeof( Food ) ) as Food ).on_ant_took_food( );
state = AntState.RETURNING_FOOD_TO_NEST;
_can_walk = false;
}
break;
}
}

void update_velocity_smoothly( )
{
//add the three components to summon to_velocity, master of direction! Vector3 to_velocity = ( _velocity_random + _velocity_pheromone + _velocity_opposing ).normalized * _speed_final; //get a mor

結果 (中文) 1:

使用 UnityEngine;使用 System.Collections.Generic;使用系统;使用 System.Collections;公共枚举 AntState{LOOKING_FOR_FOOD，RETURNING_FOOD_TO_NEST，/ * 要同时应用ATTACKING_ENEMY，WARNING_ALLIES */};公共类蚂蚁 ︰ MonoBehaviour{蚂蚁的操作取决于他的当前状态AntState 公立 {get; 私人集;}公共 Vector3 位置 {{返回 transform.position;} 得到设置 {transform.position = 值;}}对信息素的最后一个引用。用于设置下一个信息素的方向公共信息素 last_placed_pheromone {get; 套;} 一只蚂蚁的最终速度基于随机方向和信息素的影响。私人 Vector3 _velocity_random、 _velocity_pheromone、 _velocity_opposing;这是蚂蚁会使用移动的实际速度公共 Vector3 velocity_final; 公共 NodeManager node_manager {私人得到; 套;}公共 Vector3 nest_position {私人得到; 套;}随机时间间隔，所以并不是所有的蚂蚁都在同一时间更新。私人浮 _speed_random;蚂蚁会使用移动的最终速度私人浮 _speed_final;私人 bool _can_walk = true; ///启动功能是协同和功能作为更新功能。 /// IEnumerator 开始 （) {状态 = AntState.LOOKING_FOR_FOOD;所有的蚂蚁都开始在窝里。位置 = nest_position.clone （）;一个随机元素给更新时间，所以传播更新时间_speed_random = UnityEngine.Random.value * 2; 设置将火每隔这么多秒的计时器浮 t_a = 7 / _speed_final，t_b = 51;同时 (true) {t_a + = Time.deltaTime; 计时器触发间隔不同，具体取决于蚂蚁速度。这种方式，信息素滴率是平等的无论速度如何如果 (t_a > = 7 / _speed_final) {_speed_final = _speed_random + node_manager.gui_editor.get_ant_speed （);node_manager.drop_pheromone （这）;重置信息素滴计时器t_a = 0;t_b + +; }如果我们得到或提供食物我们不做任何事此更新如果 (！ _can_walk) {首先，我们不再是无法行走_can_walk = true;等待 2 秒，然后回去上班。收益新 WaitForSeconds (2); }7 信息素被删除后，在另一个方向移动了蚂蚁。如果 (t_b > = node_manager.gui_editor.get_change_direction_rate （)） {set_random_direction （);得到一个受信息素在附近的方向set_influence_from_pheromones （);最后，设置蚂蚁的速度，使它移动StartCoroutine (calculate_velocity （)）;重置计数器，t_b = 0; }如果我们处于边缘的 （我们有一个碰撞与 '墙' 网格的网格如果 (is_at_border （)） {重置计数器，所以蚂蚁不会改变方向。t_b = 0; } 收益率返回 null; } } /// 确保了蚂蚁不走出网格 /// bool is_at_border （) {foreach (在 node_manager.borders 平原 p) {Vector3 射线;如果 (p.will_collide (出射线这，NodeManager.node_size)) {让蚂蚁在相反的方向走。p.reflect_velocity （ref velocity_final、 射线）;让蚂蚁移动到新位置StartCoroutine (move_to_new_location （位置 + velocity_final，4）);返回 true; } }返回 false; } /// 计算最终的速度，然后使蚂蚁朝着这个方向前进。 /// 私人 IEnumerator calculate_velocity （) { update_velocity_smoothly （);然后，我们也在 4 秒内正朝着那速度收益 StartCoroutine (move_to_new_location （位置 + velocity_final，4）); } void OnTriggerEnter （对撞机其他） {开关 (other.gameObject.tag) {如果我们相撞巢"鸟巢"案例 ︰我们在找它如果 (状态 = = AntState.RETURNING_FOOD_TO_NEST) {状态 = AntState.LOOKING_FOR_FOOD;我们不能走在短时间内 （我们返回的食物）_can_walk = false; } 休息;如果我们与食物相撞"食品"案例 ︰和我们在寻找食物如果 (状态 = = AntState.LOOKING_FOR_FOOD) {由于食物可以消失我们吃了以后，返回如果它为 null如果 (other.gameObject = = null) 返回;否则为得到食物分量，告诉它我们吃它（.on_ant_took_food) (other.gameObject.GetComponent (typeof （食物）) 作为食品);状态 = AntState.RETURNING_FOOD_TO_NEST;_can_walk = false; }休息; } } 无效的 update_velocity_smoothly （) {添加三个组件来召唤 to_velocity，大师的方向 ！Vector3 to_velocity = （_velocity_random + _velocity_pheromone + _velocity_opposing）.normalized * _speed_final;获得铁道部

結果 (中文) 3:

使用UnityEngine；使用system.collections.generic；使用系统；使用系统集合；antstate枚举{looking_for_food，returning_food_to_nest，/ *被实施attacking_enemy，warning_allies* /}；蚂蚁：MonoBehaviour类{蚂蚁的行为取决于他现在的状态公共antstate状态{得到；私人集；}公共Vector3位置{得到{ return transform.position；}集{ transform.position =值；} }对最后一个信息素的参考。用于设置下一个信息素的方向公共信息last_placed_pheromone {有}；集；/ /蚂蚁的最终速度是基于一个随机的方向，从信息素的影响。私人_velocity_random Vector3，_velocity_pheromone，_velocity_opposing；这是蚂蚁将用以移动的实际速度到velocity_final公共；公共nodemanager node_manager {私拿；集；}到nest_position {私人得到公众；集；}/ /随机间隔，所以不是所有的蚂蚁都在同一时间更新。私有_speed_random；蚂蚁的最终速度将用于移动私有_speed_final；私人布尔_can_walk =真；/ / / <摘要>/ / /启动功能是协程和功能更新功能。/ / / /总结IEnumerator开始（）{状态= antstate.looking_for_food；/ /所有蚂蚁开始在巢。位置= nest_position克隆（）；随机元素的更新时间，所以更新时间是传播_speed_random = unityengine.random.value * 2；每一秒都会发射一个射击的计时器浮t_a = 7 / _speed_final，t_b = 51；虽然（真）{t_a + =改变；/ / / / / /定时火灾在不同的时间间隔，根据蚂蚁的速度。/ /这种方式，信息素下降的速度是相等的，无论速度如果（t_a > = 7 / _speed_final）{_speed_final = _speed_random + node_manager。gui_editor get_ant_speed（）；node_manager drop_pheromone（本）；重置信息素滴定时器t_a = 0；t_b + +；}如果我们得到或提供食物，我们不做任何更新如果（！_can_walk）{/首先，我们不再不能走路_can_walk =真；/ /等待2秒后再回去工作。收益的新waitforseconds（2）；}/ / 7后种群的下降，在另一个方向移动的蚂蚁。如果（t_b > = node_manager。gui_editor。get_change_direction_rate（））{set_random_direction（）；/ /得到，是由附近的信息素的影响方向set_influence_from_pheromones（）；最后，设置蚂蚁的速度，使它移动startcoroutine（calculate_velocity（））；/复位计数器，使t_b = 0；}如果我们是在网格的边缘（我们有一个与"墙"的网格如果（is_at_border（））{重置计数器，所以蚂蚁不改变方向。t_b = 0；}收益归零；}}/ / / <摘要>/ /确保蚂蚁没有走出网格/ / / /总结布尔is_at_border（）{foreach（纯P node_manager.borders）{到射线；如果（p.will_collide（这nodemanager.node_size，Ray））{蚂蚁在相反方向走。p.reflect_velocity（REF velocity_final，射线）；蚂蚁移动到新的位置startcoroutine（move_to_new_location（位置+ velocity_final，4））；返回true；}}返回false；}/ / / <摘要>/ / / /计算的最终的速度，然后使蚂蚁在该方向移动。/ / / /总结私人IEnumerator calculate_velocity（）{update_velocity_smoothly（）；然后，我们正朝着那个速度超过4秒的时间收益startcoroutine（move_to_new_location（位置+ velocity_final，4））；}无效ontriggerenter（对撞机等）{开关（other.gameobject.tag）{如果我们与鸟巢相撞“鸟巢”：我们在寻找它如果（状态= = antstate.returning_food_to_nest）{状态= antstate.looking_for_food；我们不能走一段短的时间（我们正在返回食物）_can_walk = false；}打破；如果我们与食物相撞“食品”：我们正在寻找食物如果（状态= = antstate.looking_for_food）{/ /因为食物可以在我们吃了它后消失，如果它是空的如果（other.gameobject = = null）返回；否则，获得食物成分，告诉它我们正在吃它（其他。gameObject. GetComponent（typeof（食品））作为食物）。on_ant_took_food（）；状态= antstate.returning_food_to_nest；_can_walk = false；}打破；}}update_velocity_smoothly（无效）{/ /添加三成分的召唤to_velocity，掌握方向！到to_velocity =（_velocity_random + _velocity_pheromone + _velocity_opposing）。归一化* _speed_final；//获得铁道部