public virtual void do_actions(AI_controller_3d controller)
{
foreach (behavior.Behavior behavior in behaviors)
{
behavior.act(controller);
}
}
public override Vector3 act(AI_controller_3d controller)
{
stats.Orbit stat = controller.stat as stats.Orbit;
if (stat == null)
{
Debug.LogError(string.Format(
"Los stat de {0} no son del tipo orbit",
controller.name));
return(Vector3.zero);
}
Vector3 target_position =
controller.target.transform.position;
float angle = controller.properties.angle_x;
angle += (Time.deltaTime * stat.orbit_delta) % 1f;
controller.properties.angle_x = angle;
Vector3 desire = helper.shapes.Ellipse.evaluate(
stat.x_radius, stat.z_radius, angle);
Vector3 result = new Vector3(
desire.x + target_position.x,
target_position.y, desire.z + target_position.z);
result = desire + target_position;
controller.controller.desire_direction =
steering.seek(
result, controller.controller.transform.position);
return(result);
}
public void prepare(AI_controller_3d controller)
{
foreach (behavior.Behavior behavior in behaviors)
{
behavior.prepare(controller);
}
}
public override Vector3 act(AI_controller_3d controller)
{
if (controller.target != null)
{
controller.controller.look_at(
controller.target.transform);
}
return(Vector3.zero);
}
public override float calculate(
AI_controller_3d controller, string angle_letter)
{
float angle = get_angle(controller, angle_letter);
angle += Time.deltaTime * delta_period % 1f;
set_angle(controller, angle_letter, angle);
angle = Mathf.Deg2Rad * 360 * angle;
return(Mathf.Sin(angle) * radius);
}
public override void prepare(AI_controller_3d controller)
{
Vector3 current_position =
controller.controller.transform.position;
Vector3 direction =
current_position
- controller.target.transform.position;
controller.properties.angle_x = helper.shapes.Ellipse
.get_progrest(direction);
}
public float get_angle(
AI_controller_3d controller, string letter)
{
switch (letter)
{
case "x":
return(controller.properties.angle_x);
case "z":
return(controller.properties.angle_z);
}
return(0f);
}
public override Vector3 act(AI_controller_3d controller)
{
var desire_direction = steering.follow_waypoints(
controller.target.gameObject,
controller.gameObject,
ref controller.properties.index);
controller.controller.desire_direction =
steering.seek(
desire_direction,
controller.controller.transform.position);
return(desire_direction);
}
public override Vector3 act(AI_controller_3d controller)
{
var properties = controller.properties;
properties.sum_delta_period += Time.deltaTime;
if (properties.sum_delta_period > delta_period)
{
foreach (var weapon in controller.weapons)
{
weapon.attack();
}
properties.sum_delta_period -= delta_period;
}
return(Vector3.zero);
}
public void set_angle(
AI_controller_3d controller, string letter,
float angle)
{
switch (letter)
{
case "x":
controller.properties.angle_x = angle;
break;
case "z":
controller.properties.angle_z = angle;
break;
}
}
public override Vector3 act(AI_controller_3d controller)
{
float x = 0, y = 0, z = 0;
if (x_behavior != null)
{
x = x_behavior.calculate(controller, "x");
}
if (y_behavior != null)
{
y = y_behavior.calculate(controller, "y");
}
if (z_behavior != null)
{
z = z_behavior.calculate(controller, "z");
}
Vector3 result = new Vector3(x, y, z) + direction_move;
controller.controller.desire_direction = result;
/*
* float angle = controller.properties.angle_x;
* angle += ( Time.time* (1/2f)) % 1f;
* controller.properties.angle_x = angle;
*
* angle = Mathf.Deg2Rad * 360 * angle;
*
* result = new Vector3(
* Mathf.Sin( angle ) * 1f, 0f, -1f );
* //result = Vector3.back + result;
*
* controller.controller.desire_direction = result;
*/
return(result);
}
public virtual void prepare(AI_controller_3d controller)
{
}
public abstract Vector3 act(AI_controller_3d controller);
public abstract float calculate(
AI_controller_3d controller, string angle);
public void update(AI_controller_3d controller)
{
do_actions(controller);
}
