protected override void OnUpdate()
{
while (_group.Length > 0)
{
var spawnCube = _group.SpawnCube[0];
var entity = _group.Entity[0];
var newEntities = new NativeArray <Entity>(spawnCube.Count, Allocator.Temp);
EntityManager.Instantiate(spawnCube.Prefab, newEntities);
for (var i = 0; i < spawnCube.Count; i++)
{
var pos = new Position
{
Value = new float3(Random.Range(-spawnCube.MaxX / 2, spawnCube.MaxX / 2),
Random.Range(-spawnCube.MaxY / 2, spawnCube.MaxY / 2),
Random.Range(-spawnCube.MaxZ / 2, spawnCube.MaxZ / 2))
};
EntityManager.SetComponentData(newEntities[i], pos);
var rotationSpeed = new RotationSpeed
{
Value = Random.Range(0, spawnCube.MaxRotationSpeed)
};
EntityManager.SetComponentData(newEntities[i], rotationSpeed);
}
newEntities.Dispose();
EntityManager.RemoveComponent <RandomSpawnCube>(entity);
UpdateInjectedComponentGroups();
}
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
var data = new RotationSpeed {
value = math.radians(rotationSpeed)
};
dstManager.AddComponentData(entity, data);
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
var data = new RotationSpeed {
RadiansPerSecond = math.radians(40)
};
//Spin the cubes
//Because of how enemy finding works (facing enemy and moving forwards) rotation doesn't really work'
dstManager.AddComponentData(entity, data);
}
public void Execute(int i)
{
var center = positions[i].Value;
for (int positionIndex = 0; positionIndex < rotationSpeedResetSpheres.Length; positionIndex++)
{
if (math.distance(rotationSpeedResetSpherePositions[positionIndex].Value, center) < spheres[positionIndex].radius)
{
rotationSpeeds[i] = new RotationSpeed
{
value = rotationSpeedResetSpheres[positionIndex].speed
};
}
}
}
public override IEnumerator ReceivePayload(VisualPayload payload)
{
RotateOverTimeSatellite.CreateRotateOverTimeSatellite(
payload.VisualData.Bound.gameObject,
RotationAxis.GetFirstValue(payload.Data),
RotationSpeed.GetFirstValue(payload.Data),
AbsoluteRotation.GetFirstValue(payload.Data));
var iterator = Router.TransmitAll(payload);
while (iterator.MoveNext())
{
yield return(null);
}
}
public void RotateTo_DoesNotOvershoot(RotationSpeed speed)
{
var rotorPair = new MockFacingRotorPair {
CurrentAngleDegrees = 20
};
var module = new EngineModule("Test", rotorPair, new RotorLimits(0, 130), new IMyThrust[0]);
// 10% frame jitter.
const float jitter = RotationSpeed.TimeStepSeconds * 0.1f;
var random = new Random();
var operation = module.RotateTo(90, speed);
var rotorVelocities = new List <float>();
// First iteration performs setup, so the clock doesn't need to tick until the next.
while (operation.MoveNext())
{
rotorVelocities.Add(rotorPair.TargetVelocityDegreesPerSecond);
// Accuracy ranges:
if (rotorVelocities.Count < speed.TimeTargetSeconds * 6)
{
// No target within deadline.
}
else if (rotorVelocities.Count < speed.TimeTargetSeconds * 12)
{
// After deadline, expect to be within 5 degrees.
Assert.That(rotorPair.CurrentAngleDegrees, Is.EqualTo(90).Within(5f));
}
else
{
// After double deadline, expect to be within 0.1 degrees.
Assert.That(rotorPair.CurrentAngleDegrees, Is.EqualTo(90).Within(0.1f));
}
if (!operation.Current)
{
break; // Completed.
}
var step = TimeSpan.FromSeconds(MathHelper.Lerp(-jitter, jitter, random.NextDouble()) + RotationSpeed.TimeStepSeconds);
rotorPair.Step(step);
Clock.AddTime(step);
}
TestContext.WriteLine("Iterations: {0} ({1} sec)", rotorVelocities.Count, rotorVelocities.Count / 6);
Assert.That(rotorPair.CurrentAngleDegrees, Is.EqualTo(90).Within(0.1f));
Assert.That(rotorVelocities, Has.None.Negative);
Assert.That(rotorVelocities, Has.Count.LessThanOrEqualTo(60));
}
public override void LoadFromXmlElement(Context context, XmlElement element)
{
base.LoadFromXmlElement(context, element);
if (element.HasAttribute("radius"))
{
Radius = Convert.ToDouble(element.GetAttribute("radius"), CultureInfo.InvariantCulture);
}
if (element.HasAttribute("slices"))
{
Slices = Convert.ToInt32(element.GetAttribute("slices"));
}
if (element.HasAttribute("stacks"))
{
Stacks = Convert.ToInt32(element.GetAttribute("stacks"));
}
if (element.HasAttribute("texture"))
{
SetTexture(element.GetAttribute("texture"));
}
if (element.HasAttribute("orbitAngle"))
{
OrbitAngle = Convert.ToDouble(element.GetAttribute("orbitAngle"));
}
var rotSpeedEl = element.SelectSingleNode("./vector[@name='RotationSpeed']") as XmlElement;
if (rotSpeedEl != null)
{
RotationSpeed.LoadFromXmlElement(rotSpeedEl);
}
var orbitEllipseElement = element.SelectSingleNode("./ellipse[@name='Orbit']") as XmlElement;
if (orbitEllipseElement != null)
{
Orbit.LoadFromXmlElement(context, orbitEllipseElement);
}
}
public static float GetSpeedValue(this RotationSpeed movementSpeed)
{
switch (movementSpeed)
{
case RotationSpeed.EXTRA_SLOW:
return(5);
case RotationSpeed.SLOW:
return(20);
case RotationSpeed.MEDIUM:
return(40);
case RotationSpeed.FAST:
return(200);
case RotationSpeed.FASTEST:
return(350);
default:
return(0);
}
}
public void Convert(Entity entity, EntityManager dstManager, GameObjectConversionSystem conversionSystem)
{
var data = new RotationSpeed();
dstManager.AddComponentData(entity, data);
}
public override void Save()
{
XmlDocument doc = new XmlDocument();
XmlElement root = doc.CreateElement("particleemitter");
doc.AppendChild(root);
root.AppendChild(doc.CreateElement("material").SimpleTag("name", Material));
root.AppendChild(doc.CreateElement("numparticles").SimpleTag("value", NumParticles.ToString()));
root.AppendChild(doc.CreateElement("updateinvisible").SimpleTag("enable", UpdateInvisible ? "true" : "false"));
root.AppendChild(doc.CreateElement("relative").SimpleTag("enable", Relative ? "true" : "false"));
root.AppendChild(doc.CreateElement("scaled").SimpleTag("enable", Scaled ? "true" : "false"));
root.AppendChild(doc.CreateElement("sorted").SimpleTag("enable", Sorted ? "true" : "false"));
root.AppendChild(doc.CreateElement("animlodbias").SimpleTag("value", AnimLodBias.ToString()));
root.AppendChild(doc.CreateElement("emittertype").ValueTag(Type.ToString().ToLower()));
if (EmitterSize != null)
{
root.AppendChild(doc.CreateElement("emittersize").ValueTag(EmitterSize.ToString()));
}
root.AppendChild(doc.CreateElement("emitterradius").ValueTag(EmitterRadius.ToString()));
XmlElement dir = doc.CreateElement("direction");
dir.SetAttribute("min", DirectionMin.ToString());
dir.SetAttribute("max", DirectionMax.ToString());
root.AppendChild(dir);
root.AppendChild(doc.CreateElement("constantforce").ValueTag(ConstantForce.ToString()));
root.AppendChild(doc.CreateElement("dampingforce").ValueTag(DampingForce.ToString()));
root.AppendChild(doc.CreateElement("activetime").ValueTag(ActiveTime.ToString()));
root.AppendChild(doc.CreateElement("inactivetime").ValueTag(InActiveTime.ToString()));
root.AppendChild(Interval.ToElement(doc.CreateElement("interval")));
root.AppendChild(EmissionRate.ToElement(doc.CreateElement("emissionrate")));
XmlElement psize = doc.CreateElement("particlesize");
psize.SetAttribute("min", MinSize.ToString());
psize.SetAttribute("max", MaxSize.ToString());
root.AppendChild(psize);
root.AppendChild(TimeToLive.ToElement(doc.CreateElement("timetolive")));
root.AppendChild(Velocity.ToElement(doc.CreateElement("velocity")));
root.AppendChild(Rotation.ToElement(doc.CreateElement("rotation")));
root.AppendChild(RotationSpeed.ToElement(doc.CreateElement("rotationspeed")));
//SIZE DELTA
XmlElement sized = doc.CreateElement("sizedelta");
sized.SetAttribute("add", SizeDelta.X.ToString());
sized.SetAttribute("mul", SizeDelta.Y.ToString());
root.AppendChild(sized);
foreach (ParticleColorFade f in ColorFade)
{
XmlElement e = doc.CreateElement("colorfade");
e.SetAttribute("color", f.Color.ToString());
e.SetAttribute("time", f.Time.ToString());
root.AppendChild(e);
}
foreach (ParticleTexAnim a in TextureAnim)
{
XmlElement e = doc.CreateElement("texanim");
e.SetAttribute("uv", a.Animation.ToString());
e.SetAttribute("time", a.Time.ToString());
root.AppendChild(e);
}
XmlWriterSettings xws = new XmlWriterSettings {
OmitXmlDeclaration = true, Indent = true
};
using (XmlWriter xw = XmlWriter.Create(System.IO.Path.ChangeExtension(Name, "xml"), xws))
doc.Save(xw);
}
private void CreateParticle(Vector3D interpolatedEffectPosition)
{
MyAnimatedParticle particle = MyTransparentGeometry.AddAnimatedParticle();
if (particle == null)
{
return;
}
particle.Type = (MyParticleTypeEnum)ParticleType.GetValue <int>();
MyUtils.AssertIsValid(m_effect.WorldMatrix);
Vector3D startOffset;
m_emitter.CalculateStartPosition(m_effect.GetElapsedTime(), MatrixD.CreateWorld(interpolatedEffectPosition, m_effect.WorldMatrix.Forward, m_effect.WorldMatrix.Up), m_effect.UserEmitterScale * m_effect.UserScale, out startOffset, out particle.StartPosition);
Vector3D particlePosition = particle.StartPosition;
m_AABB = m_AABB.Include(ref particlePosition);
Life.GetInterpolatedValue <float>(m_effect.GetElapsedTime(), out particle.Life);
float lifeVar = LifeVar;
if (lifeVar > 0)
{
particle.Life = MathHelper.Max(MyUtils.GetRandomFloat(particle.Life - lifeVar, particle.Life + lifeVar), 0.1f);
}
Vector3 vel;
Velocity.GetInterpolatedValue <Vector3>(m_effect.GetElapsedTime(), out vel);
vel.X *= m_effect.UserScale;
vel.Y *= m_effect.UserScale;
vel.Z *= m_effect.UserScale;
particle.Velocity = vel;
if (VelocityDir == MyVelocityDirEnum.FromEmitterCenter)
{
if (!MyUtils.IsZero(startOffset - particle.StartPosition))
{
float length = particle.Velocity.Length();
particle.Velocity = MyUtils.Normalize(particle.StartPosition - (Vector3D)startOffset) * length;
}
}
particle.Velocity = Vector3D.TransformNormal(particle.Velocity, GetEffect().WorldMatrix);
Angle.GetInterpolatedValue <float>(m_effect.GetElapsedTime(), out particle.Angle);
float angleVar = AngleVar;
if (angleVar > 0)
{
particle.Angle = MyUtils.GetRandomFloat(particle.Angle - AngleVar, particle.Angle + AngleVar);
}
RotationSpeed.GetInterpolatedValue <float>(m_effect.GetElapsedTime(), out particle.RotationSpeed);
float rotationSpeedVar = RotationSpeedVar;
if (rotationSpeedVar > 0)
{
particle.RotationSpeed = MyUtils.GetRandomFloat(particle.RotationSpeed - RotationSpeedVar, particle.RotationSpeed + RotationSpeedVar);
}
float radiusVar;
RadiusVar.GetInterpolatedValue <float>(m_effect.GetElapsedTime(), out radiusVar);
float lodRadius = 1.0f;
if (GetEffect().EnableLods)
{
LODRadius.GetInterpolatedValue <float>(GetEffect().Distance, out lodRadius);
}
Radius.GetInterpolatedKeys(m_effect.GetElapsedTime(),
radiusVar,
(EnableCustomRadius.GetValue <bool>() ? m_effect.UserRadiusMultiplier : 1.0f)
* lodRadius
* GetEffect().UserScale,
particle.Radius);
if (particle.Type != MyParticleTypeEnum.Point)
{
Thickness.GetInterpolatedValue <float>(m_effect.GetElapsedTime(), out particle.Thickness);
}
particle.Thickness *= lodRadius;
float colorVar;
ColorVar.GetInterpolatedValue <float>(m_effect.GetElapsedTime(), out colorVar);
Color.GetInterpolatedKeys(m_effect.GetElapsedTime(), colorVar, 1.0f, particle.Color);
Material.GetInterpolatedKeys(m_effect.GetElapsedTime(), 0, 1.0f, particle.Material);
particle.Flags = 0;
particle.Flags |= BlendTextures.GetValue <bool>() ? MyAnimatedParticle.ParticleFlags.BlendTextures : 0;
particle.Flags |= GetEffect().IsInFrustum ? MyAnimatedParticle.ParticleFlags.IsInFrustum : 0;
particle.Start(this);
m_particles.Add(particle);
}
private void Rotation()
{
Vector3 direction = target.transform.position - transform.position;
Quaternion lookRotation = Quaternion.LookRotation(direction);
Vector3 rotation = Quaternion.Lerp(transform.rotation, lookRotation, Time.deltaTime * RotationSpeed.GetBaseValue()).eulerAngles;
transform.rotation = Quaternion.Euler(0f, rotation.y, 0f);
}
private void InstantiateCharacters(int entityCount)
{
if (entityCount <= 0)
{
return;
}
var entityArray = new NativeArray <Entity>(entityCount, Allocator.TempJob);
EntityManager.CreateEntity(m_Archetype, entityArray);
var terrain = Terrain.activeTerrain;
for (var entityIndex = 0; entityIndex < entityArray.Length; entityIndex++)
{
var type = (ViewType)m_Random.NextInt(Enum.GetValues(typeof(ViewType)).Length);
var entity = entityArray[entityIndex];
var movementSpeed = new MovementSpeed();
var rotationSpeed = new RotationSpeed();
var rotationSpeedModifier = new RotationSpeedModifier();
var walkSpeedModifier = new WalkSpeedModifier();
var chargeSpeedModifier = new ChargeSpeedModifier();
var engageSqrRadius = new EngageSqrRadius();
var attackDistance = new AttackDistance {
Min = 1.5f, Max = 2
};
var attackAnimationDuration = new AttackAnimationDuration();
var attackDamage = new AttackDamage();
var attackSpeed = new AttackSpeed();
var maxHealth = new MaxHealth();
var health = new Health();
var healthRegeneration = new HealthRegeneration();
var viewInfo = new ViewInfo();
PostUpdateCommands.SetComponent(entity, new Translation {
Value = terrain.GetRandomPosition()
});
switch (type)
{
case ViewType.Knight:
PostUpdateCommands.AddComponent(entity, new Knight());
PostUpdateCommands.AddComponent(entity, new Faction {
Value = FactionType.Alliance
});
movementSpeed.Value = m_Random.NextFloat(1, 3);
rotationSpeed.Value = m_Random.NextFloat(1, 3);
rotationSpeedModifier.Value = m_Random.NextFloat(1.25f, 2);
walkSpeedModifier.Value = m_Random.NextFloat(0.9f, 1.25f);
chargeSpeedModifier.Value = m_Random.NextFloat(2, 3);
engageSqrRadius.Value = m_Random.NextFloat(400, 2500);
attackAnimationDuration.Value = 1;
attackDamage.Value = m_Random.NextInt(10, 30);
attackSpeed.Value = m_Random.NextFloat(1, 3);
maxHealth.Value = m_Random.NextInt(100, 200);
health.Value = maxHealth.Value;
healthRegeneration.Value = m_Random.NextFloat(1, 3);
viewInfo.Type = ViewType.Knight;
break;
case ViewType.OrcWolfRider:
PostUpdateCommands.AddComponent(entity, new OrcWolfRider());
PostUpdateCommands.AddComponent(entity, new Faction {
Value = FactionType.Horde
});
movementSpeed.Value = m_Random.NextFloat(1, 3);
rotationSpeed.Value = m_Random.NextFloat(1, 3);
rotationSpeedModifier.Value = m_Random.NextFloat(1.25f, 2);
walkSpeedModifier.Value = m_Random.NextFloat(0.9f, 1.25f);
chargeSpeedModifier.Value = m_Random.NextFloat(2, 3);
engageSqrRadius.Value = m_Random.NextFloat(400, 2500);
attackAnimationDuration.Value = 1.333f;
attackDamage.Value = m_Random.NextInt(10, 30);
attackSpeed.Value = m_Random.NextFloat(1, 3);
maxHealth.Value = m_Random.NextInt(100, 200);
health.Value = maxHealth.Value;
healthRegeneration.Value = m_Random.NextFloat(1, 3);
viewInfo.Type = ViewType.OrcWolfRider;
break;
case ViewType.Skeleton:
PostUpdateCommands.AddComponent(entity, new Skeleton());
PostUpdateCommands.AddComponent(entity, new Faction {
Value = FactionType.Legion
});
movementSpeed.Value = m_Random.NextFloat(1, 3);
rotationSpeed.Value = m_Random.NextFloat(1, 3);
rotationSpeedModifier.Value = m_Random.NextFloat(1.25f, 2);
walkSpeedModifier.Value = m_Random.NextFloat(0.9f, 1.25f);
chargeSpeedModifier.Value = m_Random.NextFloat(2, 3);
engageSqrRadius.Value = m_Random.NextFloat(400, 2500);
attackAnimationDuration.Value = 2.4f;
attackDamage.Value = m_Random.NextInt(10, 30);
attackSpeed.Value = m_Random.NextFloat(1, 3);
maxHealth.Value = m_Random.NextInt(100, 200);
health.Value = maxHealth.Value;
healthRegeneration.Value = m_Random.NextFloat(1, 3);
viewInfo.Type = ViewType.Skeleton;
break;
}
PostUpdateCommands.SetComponent(entity, movementSpeed);
PostUpdateCommands.SetComponent(entity, rotationSpeed);
PostUpdateCommands.SetComponent(entity, rotationSpeedModifier);
PostUpdateCommands.SetComponent(entity, walkSpeedModifier);
PostUpdateCommands.SetComponent(entity, chargeSpeedModifier);
PostUpdateCommands.SetComponent(entity, engageSqrRadius);
PostUpdateCommands.SetComponent(entity, attackDistance);
PostUpdateCommands.SetComponent(entity, attackAnimationDuration);
PostUpdateCommands.SetComponent(entity, attackDamage);
PostUpdateCommands.SetComponent(entity, attackSpeed);
PostUpdateCommands.SetComponent(entity, maxHealth);
PostUpdateCommands.SetComponent(entity, health);
PostUpdateCommands.SetComponent(entity, healthRegeneration);
PostUpdateCommands.SetComponent(entity, viewInfo);
#if UNITY_EDITOR
EntityManager.SetName(entity, $"{viewInfo.Type} AI {entity}");
#endif
}
entityArray.Dispose();
}
