public override void CollectObservations(VectorSensor sensor)
{
sensor.AddObservation(m_Ship.Throttle);
sensor.AddObservation(m_Ship.Pitch);
sensor.AddObservation(m_Ship.Roll);
sensor.AddObservation(m_Ship.NormPosition);
sensor.AddObservation(m_Ship.NormOrientation);
sensor.AddObservation(Normalization.Sigmoid(m_Ship.LocalSpin));
sensor.AddObservation(Normalization.Sigmoid(m_Ship.LocalVelocity));
Vector3 pos = m_Ship.transform.position;
Vector3 fwd = m_Ship.transform.forward;
m_Targets.Clear();
foreach (var target in m_SensorComponent.GetDetectedGameObjects(m_TargetTag))
{
Vector3 delta = target.transform.position - pos;
if (Vector3.Angle(fwd, delta) < m_TargetFollowAngle &&
delta.sqrMagnitude < m_TargetFollowDistanceSqr)
{
m_Targets.Add(target);
}
}
}
public override void CollectObservations(VectorSensor sensor)
{
if (opponent == null)
{
return;
}
actionStep = 0;
Transform rt = root.transform;
Vector3 inclination = new Vector3(rt.right.y, rt.up.y, rt.forward.y);
sensor.AddObservation(inclination);
sensor.AddObservation(Normalization.Sigmoid(CrntForce, 0.25f) * 2f - 1f);
CrntForce = 0;
// Observe positions relative to this agent's root (hips).
// All vectors are localized (root.InverseTransformVector(v))
// and normalized using a sigmoid function. The idea here is
// that small value changes matter less the farther away an
// observed object is, or the faster it is moving.
// The sigmoid function provides a higher value resolution
// for small vectors and asymptotes towards -1/+1.
Vector3 rootPos = rt.position;
// This agent.
// Hips position = root position. Since all positions are relative to
// this agent's root, we don't observe this, as it will always be 0/0/0.
AddVectorObs(sensor, Hips.Velocity);
AddVectorObs(sensor, Hips.AngularVelocity);
AddVectorObs(sensor, Head.Position - rootPos);
AddVectorObs(sensor, Head.Velocity);
AddVectorObs(sensor, LeftHand.Position - rootPos);
AddVectorObs(sensor, LeftHand.Velocity);
AddVectorObs(sensor, RightHand.Position - rootPos);
AddVectorObs(sensor, RightHand.Velocity);
AddVectorObs(sensor, LeftFoot.Position - rootPos);
AddVectorObs(sensor, LeftFoot.Velocity);
AddVectorObs(sensor, RightFoot.Position - rootPos);
AddVectorObs(sensor, RightFoot.Velocity);
// Opponent agent.
AddVectorObs(sensor, opponent.Hips.Position - rootPos);
AddVectorObs(sensor, opponent.Hips.Velocity);
AddVectorObs(sensor, opponent.Hips.AngularVelocity);
AddVectorObs(sensor, opponent.Head.Position - rootPos);
AddVectorObs(sensor, opponent.Head.Velocity);
AddVectorObs(sensor, opponent.LeftHand.Position - rootPos);
AddVectorObs(sensor, opponent.LeftHand.Velocity);
AddVectorObs(sensor, opponent.RightHand.Position - rootPos);
AddVectorObs(sensor, opponent.RightHand.Velocity);
AddVectorObs(sensor, opponent.LeftFoot.Position - rootPos);
AddVectorObs(sensor, opponent.LeftFoot.Velocity);
AddVectorObs(sensor, opponent.RightFoot.Position - rootPos);
AddVectorObs(sensor, opponent.RightFoot.Velocity);
// Normalized rotations (wrapped eulers / 180).
sensor.AddObservation(GetJointObs());
// Normalized distances.
sensor.AddObservation(GetRayObs());
// TODO AddObservation DownStepCount / MaxDownSteps
}
public override void CollectObservations(VectorSensor sensor)
{
sensor.AddObservation(m_Car.Throttle);
sensor.AddObservation(m_Car.Steering);
sensor.AddObservation(m_Car.Gyro);
sensor.AddObservation(Normalization.Sigmoid(m_Car.LocalSpin));
sensor.AddObservation(Normalization.Sigmoid(m_Car.LocalVelocity));
}
public override void CollectObservations(VectorSensor sensor)
{
sensor.AddObservation(m_Ship.Throttle);
sensor.AddObservation(m_Ship.Pitch);
sensor.AddObservation(m_Ship.Roll);
sensor.AddObservation(m_Ship.NormPosition);
sensor.AddObservation(m_Ship.NormOrientation);
sensor.AddObservation(Normalization.Sigmoid(m_Ship.LocalSpin));
sensor.AddObservation(Normalization.Sigmoid(m_Ship.LocalVelocity));
Vector3 shipPos = m_Ship.transform.position;
Vector3 shipFwd = m_Ship.transform.forward;
if (HasTargetLock(shipPos, shipFwd, out Vector3 targetPos) && CanShoot())
{
GunPosition = shipPos + shipFwd;
GunDirection = (targetPos - shipPos).normalized;
m_Bullets.Shoot(this);
m_ShotTime = Time.time;
}
}
private void AddVectorObs(VectorSensor sensor, Vector3 v)
{
sensor.AddObservation(Normalization.Sigmoid(root.Localize(v)));
}
public override void CollectObservations(VectorSensor sensor)
{
// Sort by relative lead.
foreach (BikeAgent other in allAgents)
{
other.Shared.TmpDelta = Mathf.DeltaAngle(
Shared.CrntPos.PosDeg, other.Shared.CrntPos.PosDeg);
}
Array.Sort(allAgents);
int index = Array.IndexOf(allAgents, this);
if (index < crntRank)
{
AddReward(loosingRankPenalty);
}
crntRank = index;
// Filter closest.
observedAgents.Clear();
observedAgents.AddRange(allAgents);
observedAgents.RemoveAt(index);
while (observedAgents.Count > observedAgentsCount)
{
if (Mathf.Abs(observedAgents[0].Shared.TmpDelta) >
Mathf.Abs(observedAgents[observedAgents.Count - 1].Shared.TmpDelta))
{
observedAgents.RemoveAt(0);
}
else
{
observedAgents.RemoveAt(observedAgents.Count - 1);
}
}
foreach (BikeAgent other in observedAgents)
{
bool ignore = Mathf.Abs(other.Shared.TmpDelta) > maxAgentDistance;
sensor.AddObservation(Mathf.Clamp(
other.Shared.TmpDelta / maxAgentDistance, -1f, 1f));
sensor.AddObservation(ignore ? 0 : other.Shared.NormXPos);
// Relative velocity in local space.
sensor.AddObservation(ignore ? Vector3.zero : Normalization
.Sigmoid(Bike.Localize(other.Shared.Velocity - Bike.Body.velocity)));
}
// Bike physics.
Vector3 pV3 = Position;
Vector3 fwd = Bike.transform.forward;
Vector3 locVelocity = Bike.Localize(Bike.Body.velocity);
Vector3 locAngVelocity = Bike.Localize(Bike.Body.angularVelocity);
sensor.AddObservation(Mathf.Clamp(locVelocity.z / 30f - 1f, -1f, 1f)); // 0/+60
sensor.AddObservation(Normalization.Sigmoid(locVelocity.x));
sensor.AddObservation(Normalization.Sigmoid(locVelocity.y));
sensor.AddObservation(Normalization.Sigmoid(locAngVelocity));
sensor.AddObservation(crntPos.GetNormLocalXPos(pV3));
sensor.AddObservation(crntPos.GetNormLocalYAngle(fwd));
sensor.AddObservation(Bike.Inclination);
if (isDiscrete)
{
sensor.AddObservation(Bike.Throttle);
sensor.AddObservation(Bike.Steer);
}
// Modify boost.
crntSeg = track.Segments.FindClosest(pV3, crntSeg);
if (track.NormLanes.Contains(crntSeg.GetNormLocalXPos(pV3), out index))
{
crntBoost = Mathf.Clamp(crntBoost +
crntSeg.BoostValues[index] * boostStrength, -1f, 1f);
}
sensor.AddObservation(crntBoost);
// Look ahead.
index = crntSeg.Index;
foreach (int offset in lookAheadBoost)
{
Segment seg = track.Segments[index + offset];
sensor.AddObservation(seg.BoostValues);
}
foreach (int offset in lookAheadCurve)
{
Segment seg = track.Segments[index + offset];
float curve = Vector3.SignedAngle(crntSeg.TangentXZ, seg.TangentXZ, Vector3.up);
sensor.AddObservation(curve / maxCurve);
float slope = seg.PosV3.y - crntSeg.PosV3.y;
sensor.AddObservation(slope / maxSlope);
}
}
/// <inheritdoc/>
public override void CollectObservations(VectorSensor sensor)
{
sensor.AddObservation(m_Car.NormSteer);
sensor.AddObservation(Normalization.Sigmoid(m_Car.LocalSpin));
sensor.AddObservation(Normalization.Sigmoid(m_Car.LocalVelocity));
}
