public override Output Run(Input input)
{
var output = new Output
{
Data = new ulong[] { 0 },
Energy = -1,
};
var magnitude = Convert.ScaledFloat(input.Data[0]);
var cost = Math.Max(MinCost, (long)(magnitude * EnergyScalar));
if ((ulong)cost > input.AvailableEnergy)
{
return(output);
}
var position = transform.position;
var direction = transform.forward;
var distance = magnitude * DistanceScalar;
var hit = Physics.Raycast(position, direction, distance);
output.Data = new[] { hit?input.Data[0] : 0 };
output.Energy = -cost;
return(output);
}
public override Output Run(Input input)
{
return(new Output
{
Data = new [] { RandomUlong() },
Energy = -1,
});
}
public override Output Run(Input input)
{
return(new Output
{
Data = new ulong[] {},
Energy = -1,
});
}
public override Output Run(Input input)
{
return(new Output
{
Data = new [] { ulong.MaxValue - input.Data[0] },
Energy = -1,
});
}
public override Output Run(Input input)
{
return(new Output
{
Data = new [] { value },
Energy = -1,
});
}
public override Output Run(Input input)
{
return(new Output
{
Data = new [] { memory.Data },
Energy = -EnergyCost,
});
}
public override Output Run(Input input)
{
memory.Data = input.Data[0];
return(new Output
{
Data = new [] { input.Data[0] },
Energy = -EnergyCost,
});
}
public override Output Run(Input input)
{
// Return the first input value if the second input evaluates to true
return(new Output
{
Data = new [] { Convert.Bool(input.Data[1]) ? input.Data[0] : 0 },
Energy = -EnergyCost,
});
}
public override Output Run(Input input)
{
var output = new Output
{
Data = new ulong[] { 0 },
Energy = -BaseEnergyCost,
};
if (input.Data[0] == 0 || input.AvailableEnergy <= BaseEnergyCost)
{
return(output);
}
var energyAmount = (ulong)(Convert.ScaledFloat(input.Data[0]) * (input.AvailableEnergy - BaseEnergyCost));
if (energyAmount < MinEnergyAmount || energyAmount < BaseEnergyCost)
{
return(output);
}
var cost = energyAmount + copyCost + BaseEnergyCost;
if (cost > input.AvailableEnergy || cost < energyAmount)
{
return(output);
}
var child = Object.Instantiate(t.gameObject, t.position + new Vector3(0, 0, 5f), t.rotation, genGroup);
if (child == null)
{
return(output);
}
var go = child.GetComponent <Organism>();
if (go == null)
{
return(output);
}
var config = parent.Config;
config.Seed = UnityEngine.Random.Range(int.MinValue, int.MaxValue);
config.StartingEnergy = energyAmount;
config.Mutate = true;
config.NewGenome = null;
config.Generation++;
config.Born = Time.frameCount;
go.Initialize(config);
output.Data = new [] { ulong.MaxValue };
output.Energy = -(long)cost;
return(output);
}
public override Output Run(Input input)
{
var data = new ulong[outputCount];
for (var i = outputCount - 1; i >= 0; i--)
{
data[i] = input.Data[0];
}
return(new Output
{
Data = data,
Energy = -energyCost,
});
}
public override Output Run(Input input)
{
var output = new Output
{
Data = new ulong[] { 0 },
Energy = -1,
};
var position = t.position;
var direction = Convert.Vector3(input.Data[0]);
var mag = direction.magnitude;
var cost = (long)(mag * EnergyScalar);
if (cost < 1 || (ulong)cost > input.AvailableEnergy)
{
return(output);
}
var distance = mag * DistanceScalar;
var hit = Physics.Raycast(position, direction, out var hitInfo, distance);
if (!hit || hitInfo.transform == null || Vector3.Distance(t.position, hitInfo.transform.position) > MaxAllowableDistance)
{
output.Energy = -cost;
return(output);
}
var energy = hitInfo.transform.GetComponent <IEdible>()?.Eat() ?? 0;
// If the energy received from food is greater than sensitivity value, output max value; otherwise output ratio
var result = energy >= sensitivity ? ulong.MaxValue : (ulong.MaxValue / (ulong)sensitivity) * (ulong)energy;
output.Data = new [] { result };
output.Energy = energy - cost;
return(output);
}
public override Output Run(Input input)
{
var output = new Output
{
Data = new [] { input.Data[0] },
Energy = -1,
};
var magnitude = Convert.ScaledFloat(input.Data[0]);
var cost = Math.Max(MinCost, (long)(magnitude * EnergyScalar));
if ((ulong)cost > input.AvailableEnergy)
{
return(output);
}
var direction = rb.transform.forward;
var force = direction * (magnitude * ForceScalar * Time.deltaTime);
rb.AddForce(force);
output.Energy = -cost;
return(output);
}
public override Output Run(Input input)
{
var output = new Output
{
Data = new[] { input.Data[0] },
Energy = -1,
};
var multiplier = Convert.ScaledSignedFloat(input.Data[0]);
var cost = Math.Max(MinCost, (long)(Math.Abs(multiplier) * EnergyScalar));
if ((ulong)cost > input.AvailableEnergy)
{
return(output);
}
var rotationAxis = rb.transform.up;
var torque = rotationAxis * (multiplier * TorqueScalar * Time.deltaTime);
rb.AddTorque(torque);
output.Energy = -cost;
return(output);
}
