public override void ActiveUpdate()
{
float emissive = MathExtensions.TrianglePulse(m_updateCount, 1f, 150);
//MyCubeBlockEmissive.SetEmissiveParts((MyEntity)m_owner, emissive, Color.FromNonPremultiplied(m_color) * 0f, Color.White);
m_owner.SetEmissiveParts("Emissive-Beacon", Color.FromNonPremultiplied(m_color) * emissive, 1f);
m_owner.SetEmissiveParts("Emissive0", Color.FromNonPremultiplied(m_color) * emissive, emissive);
MyCubeBlockEmissive.SetEmissiveParts((MyEntity)m_owner, emissive, Color.FromNonPremultiplied(m_color) * emissive, Color.White);
if (!m_owner.IsFunctional || !m_owner.Enabled)
{
if (m_soundEmitter != null)
{
if (m_soundEmitter.IsPlaying)
{
m_soundEmitter.StopSound(true);
}
}
m_light.Intensity = 0f;
m_light.GlareIntensity = 0f;
m_light.UpdateLight();
return;
}
if (m_soundEmitter == null)
{
m_soundPair = new MySoundPair("NaniteBeacon");
m_soundEmitter = new MyEntity3DSoundEmitter((MyEntity)m_owner, true);
m_soundEmitter.PlaySound(m_soundPair, true);
}
else if (!m_soundEmitter.IsPlaying)
{
m_soundEmitter.PlaySound(m_soundPair, true);
}
m_light.Intensity = MathExtensions.TrianglePulse(m_updateCount, 0.8f, 150);
m_light.GlareIntensity = MathExtensions.TrianglePulse(m_updateCount, 0.8f, 150);
//m_light.GlareSize = 0.098f;
Vector3D position = m_owner.GetPosition();
if (m_owner.CubeGrid.GridSizeEnum == VRage.Game.MyCubeSize.Small)
{
Vector3D localPosition = new Vector3D(0f, 0.30f, 0f);
position = Vector3D.Transform(localPosition + m_localOffset, m_owner.WorldMatrix);
}
else
{
Vector3D localPosition = new Vector3D(0f, -0.05f, 0f);
position = Vector3D.Transform(localPosition + m_localOffset, m_owner.WorldMatrix);
}
m_light.Position = position;
m_light.UpdateLight();
m_updateCount++;
}
public override void UpdateBeforeSimulation()
{
try
{
bool shouldSpin = block.IsWorking; // if block is functional and enabled and powered.
if (!shouldSpin && Math.Abs(targetSpeedMultiplier) < 0.00001f)
{
return;
}
if (shouldSpin && targetSpeedMultiplier < 1)
{
targetSpeedMultiplier = Math.Min(targetSpeedMultiplier + ACCELERATE_PERCENT_PER_TICK, 1);
}
else if (!shouldSpin && targetSpeedMultiplier > 0)
{
targetSpeedMultiplier = Math.Max(targetSpeedMultiplier - DEACCELERATE_PERCENT_PER_TICK, 0);
}
var camPos = MyAPIGateway.Session.Camera.WorldMatrix.Translation; // local machine camera position
if (Vector3D.DistanceSquared(camPos, block.GetPosition()) > MAX_DISTANCE_SQ)
{
return;
}
MyEntitySubpart subpart;
if (Entity.TryGetSubpart(SUBPART_NAME, out subpart)) // subpart does not exist when block is in build stage
{
if (subpartFirstFind) // first time the subpart was found
{
subpartFirstFind = false;
subpartLocalMatrix = subpart.PositionComp.LocalMatrix;
}
if (targetSpeedMultiplier > 0)
{
subpartLocalMatrix *= Matrix.CreateFromAxisAngle(ROTATION_AXIS, MathHelper.ToRadians(targetSpeedMultiplier * DEGREES_PER_TICK));
subpartLocalMatrix = Matrix.Normalize(subpartLocalMatrix); // normalize to avoid any rotation inaccuracies over time resulting in weird scaling
}
subpart.PositionComp.LocalMatrix = subpartLocalMatrix;
}
}
catch (Exception e)
{
AddToLog(e);
}
}
bool CheckBlockForSuppression(IMyFunctionalBlock block)
{
if (block == null || !IsWorking || !Antenna.IsBroadcasting)
{
return(false);
}
if (AffectBlocksAttachedToOwnGrid)
{
if (Antenna.SlimBlock.CubeGrid.IsSameConstructAs(block.SlimBlock.CubeGrid))
{
return(false);
}
}
return(Vector3D.Distance(Antenna.GetPosition(), block.GetPosition()) < Antenna.Radius);
}
void NewAdjustTest(Vector3D closestPoint, IMyFunctionalBlock reference, double distanceFromVectorPoint)
{
foreach (IMyThrust thruster in backThrusterGroup)
{
thruster.ThrustOverridePercentage = 0f;
}
closestPoint -= reference.GetPosition(); //converting to relative coords;
Vector3D leftDir = new Vector3D();
Vector3D rightDir = new Vector3D();
Vector3D upDir = new Vector3D();
Vector3D downDir = new Vector3D();
foreach (IMyThrust thruster in allThrusters)
{
if (thruster.Orientation.Forward == Base6Directions.GetFlippedDirection(reference.Orientation.Up))
{
downThrusterGroup.Add(thruster);
}
else if (thruster.Orientation.Forward == reference.Orientation.Up)
{
upThrusterGroup.Add(thruster);
}
else if (thruster.Orientation.Forward == reference.Orientation.Left)
{
leftThrusterGroup.Add(thruster);
}
else if (thruster.Orientation.Forward == Base6Directions.GetFlippedDirection(reference.Orientation.Left))
{
rightThrusterGroup.Add(thruster);
}
}
leftDir = leftThrusterGroup.First().WorldMatrix.Forward;
rightDir = rightThrusterGroup.First().WorldMatrix.Forward;
upDir = upThrusterGroup.First().WorldMatrix.Forward;
downDir = downThrusterGroup.First().WorldMatrix.Forward;
Echo("Distance From Docking Vector: " + distanceFromVectorPoint);
double leftDot = leftDir.Dot(closestPoint);
double rightDot = rightDir.Dot(closestPoint);
double upDot = upDir.Dot(closestPoint);
double downDot = downDir.Dot(closestPoint);
if (leftDot < rightDot)
{
if (Math.Abs(leftDot) > 0.1)
{
ApplyProperThrust(leftThrusterGroup, rightThrusterGroup, leftDir, leftDot, closestPoint, distanceFromVectorPoint);
}
else
if (Math.Abs(rightDot) > 0.1)
{
ApplyProperThrust(rightThrusterGroup, leftThrusterGroup, rightDir, rightDot, closestPoint, distanceFromVectorPoint);
}
}
if (upDot < downDot)
{
if (Math.Abs(upDot) > 0.1)
{
ApplyProperThrust(upThrusterGroup, downThrusterGroup, upDir, upDot, closestPoint, distanceFromVectorPoint);
}
else
if (Math.Abs(downDot) > 0.1)
{
ApplyProperThrust(downThrusterGroup, upThrusterGroup, downDir, downDot, closestPoint, distanceFromVectorPoint);
}
}
}
void findReceivers()
{
m_receivers.Clear();
if (m_functionalBlock.IsFunctional && m_functionalBlock.Enabled)
{
m_currentOutput = m_resourceSink.CurrentInputByType(m_electricityDefinition);
float falloffMultiplier = m_falloffRange;
m_maxRangeSquared = (m_currentOutput * 1000f - 10f) / m_falloffRange;
foreach (var radialTransmitter in TransmissionManager.radialTransmitters)
{
if (radialTransmitter.Key != m_entityId)
{
if (m_sender)
{
if (m_transmittedPower != 0f)
{
if (radialTransmitter.Value.channel == m_channel)
{
if (!radialTransmitter.Value.sender)
{
if (radialTransmitter.Value.enabled)
{
float distanceSquared = (float)Vector3D.DistanceSquared(m_functionalBlock.GetPosition(), radialTransmitter.Value.functionalBlock.GetPosition());
if (distanceSquared < m_maxRangeSquared)
{
float powerToTransfer = (m_currentOutput * 1000f - distanceSquared * falloffMultiplier) / 1000f;
if ((powerToTransfer + radialTransmitter.Value.currentInput) > radialTransmitter.Value.strength)
{
powerToTransfer = radialTransmitter.Value.strength - radialTransmitter.Value.currentInput;
}
radialTransmitter.Value.currentInput += powerToTransfer;
m_receivers.Add(radialTransmitter.Value.functionalBlock, new ReceiverInfo(powerToTransfer, radialTransmitter.Value.strength));
}
}
}
}
}
}
}
}
}
}
public void maintainConnection()
{
//MyAPIGateway.Utilities.ShowNotification ("MAINTAIN", 1000, MyFontEnum.White);
if (m_target != null)
{
if (m_target.functionalBlock == null)
{
//MyAPIGateway.Utilities.ShowNotification ("TARGET REMOVED", 1000, MyFontEnum.White);
m_target = null;
}
}
if (m_target != null)
{
//MyAPIGateway.Utilities.ShowNotification ("GOT TARGET", 1000, MyFontEnum.White);
if (m_targetIdOld != m_target.id)
{
m_target = null;
}
else
{
m_targetIdOld = m_target.id;
}
}
if (m_target == null)
{
//MyAPIGateway.Utilities.ShowNotification ("LF TARGET", 1000, MyFontEnum.White);
foreach (var transmitter in TransmissionManager.opticalTransmitters)
{
//MyAPIGateway.Utilities.ShowNotification ("CHECK " + transmitter.Value.id + " " + m_targetId, 1000, MyFontEnum.White);
if (transmitter.Value.id == m_targetId)
{
if (!transmitter.Value.sender)
{
if (transmitter.Value.functionalBlock.Enabled)
{
//MyAPIGateway.Utilities.ShowNotification ("GOT TARGET", 1000, MyFontEnum.White);
m_target = transmitter.Value;
m_targetIdOld = m_target.id;
}
}
}
//MyAPIGateway.Utilities.ShowNotification ("COUNT: " + TransmissionManager.opticalTransmitters.Count, 1667);
}
}
if (m_target != null)
{
//MyAPIGateway.Utilities.ShowNotification ("RECEIVER: " + m_target.functionalBlock.EntityId, 1000, MyFontEnum.White);
m_targetVisible = false;
Vector3D thisPosition = m_functionalBlock.GetPosition();
Vector3D targetPosition = m_target.functionalBlock.GetPosition();
if (m_transmittedPower != m_oldTransmittedPower)
{
m_currentRequiredInput = m_transmittedPower;
m_resourceSink.SetRequiredInputByType(m_electricityDefinition, m_transmittedPower);
//MyAPIGateway.Utilities.ShowNotification ("COUNT: " + TransmissionManager.opticalTransmitters.Count, 3000, MyFontEnum.Red);
m_oldTransmittedPower = m_transmittedPower;
}
if (m_target.enabled)
{
double distance = Vector3D.DistanceSquared(thisPosition, targetPosition);
//MyAPIGateway.Utilities.ShowNotification ("RANGE: " + distance + ":" + m_maxRangeSquared, 1000, MyFontEnum.White);
if (distance < m_maxRangeSquared)
{
Vector3D direction = targetPosition - thisPosition;
direction.Normalize();
//MyAPIGateway.Utilities.ShowNotification ("VEC: " + thisPosition + ":" + targetPosition + ":" + direction * 20, 1000, MyFontEnum.White);
if (!MyAPIGateway.Entities.IsRaycastBlocked(thisPosition + direction * m_rayOffset, targetPosition - direction * m_target.rayOffset))
{
m_targetVisible = true;
//MyAPIGateway.Utilities.ShowNotification ("" + m_target.functionalBlock.CubeGrid.EntityId + " VISIBLE", 1000);
return;
}
else
{
m_targetVisible = false;
//MyAPIGateway.Utilities.ShowNotification ("BLOCKED", 1000, MyFontEnum.Red);
}
}
}
}
m_targetVisible = false;
if (m_currentRequiredInput != 0)
{
m_resourceSink.SetRequiredInputByType(m_electricityDefinition, 0);
m_oldTransmittedPower = 0;
m_currentRequiredInput = 0;
}
}
public override void UpdateBeforeSimulation()
{
base.UpdateBeforeSimulation();
try
{
if (cube?.CubeGrid?.Physics == null) //ignore ghost grids
{
return;
}
if (MyAPIGateway.Multiplayer.IsServer)
{
Vector3D direction;
Vector3D origin;
_currentShootTime = GetLastShootTime();
//fire weapon
if (_currentShootTime != _lastShootTime && !_firstUpdate)
{
if (Entity is IMyLargeTurretBase)
{
Vector3D.CreateFromAzimuthAndElevation(turret.Azimuth, turret.Elevation, out direction);
direction = Vector3D.TransformNormal(direction, turret.WorldMatrix);
origin = turret.WorldMatrix.Translation + turret.WorldMatrix.Up * 1.75 + direction * 0.5;
}
else
{
direction = block.WorldMatrix.Forward;
origin = block.WorldMatrix.Translation + direction * -2.5; //for cushion
}
var velocity = block.CubeGrid.Physics.LinearVelocity;
//var projectile = new ArmorPiercingProjectileSimulation(origin, direction, velocity, this._desiredSpeed, this._maxTrajectory, 0f, 0f, _projectileDamage, 50f, Entity.EntityId, _trailColor, _trailScale, true, true, true);
var fireData = new RailgunFireData()
{
ShooterVelocity = velocity,
Origin = origin,
Direction = direction,
ShooterID = Entity.EntityId
};
RailgunCore.ShootProjectileServer(fireData);
//RailgunCore.AddProjectile(projectile);
_isReloading = true;
_currentReloadTicks = 0;
//Apply recoil force
var centerOfMass = block.CubeGrid.Physics.CenterOfMassWorld;
var forceVector = -direction * _backkickForce;
block.CubeGrid.Physics.AddForce(MyPhysicsForceType.APPLY_WORLD_IMPULSE_AND_WORLD_ANGULAR_IMPULSE, forceVector, block.GetPosition(), null);
//MyAPIGateway.Utilities.ShowNotification("Shot", 3000);
}
_lastShootTime = _currentShootTime;
sink.Update();
_firstUpdate = false;
}
ShowReloadMessage();
//MyAPIGateway.Utilities.ShowNotification($"Power draw: {GetPowerInput(false):n0} MW | reloading?: {_isReloading} | max: {sink.MaxRequiredInputByType(resourceId)} | current ticks {_currentReloadTicks}", 16, MyFontEnum.Blue);
}
catch (Exception e)
{
MyAPIGateway.Utilities.ShowNotification("Exception in update", 16, MyFontEnum.Red);
MyLog.Default.WriteLine(e);
}
}
public bool StaticWeaponAlignedToTarget(bool mustContactHostile = false)
{
var waypointCoords = _behavior.AutoPilot.GetCurrentWaypoint();
var targetCoords = _behavior.AutoPilot.Targeting.TargetLastKnownCoords;
var shootableCoords = Vector3D.Zero;
var collisionCoords = Vector3D.Zero;
bool isWaypointTarget = _weaponSystem.WaypointIsTarget;
bool hasValidTarget = _behavior.AutoPilot.Targeting.HasTarget();
bool canShootWaypoint = false;
bool canShootTarget = false;
bool canShootCollision = false;
var trajectory = _weaponSystem.MaxStaticWeaponRange > -1 ? MathHelper.Clamp(_ammoMaxTrajectory, 0, _weaponSystem.MaxStaticWeaponRange) : _ammoMaxTrajectory;
//Waypoint Details
if (isWaypointTarget)
{
canShootWaypoint = StaticDistanceAndAngleCheck(waypointCoords, trajectory);
}
//Target Details
if (!canShootWaypoint && hasValidTarget)
{
canShootTarget = StaticDistanceAndAngleCheck(targetCoords, trajectory);
}
shootableCoords = canShootWaypoint ? waypointCoords : (canShootTarget ? targetCoords : Vector3D.Zero);
var maxTargetTrajectory = shootableCoords != Vector3D.Zero ? Vector3D.Distance(shootableCoords, _block.GetPosition()) : trajectory;
//Collision
var collision = _behavior.AutoPilot.Collision.GetResult(_direction);
bool hasCollision = false;
bool hostile = false;
bool collisionIsGrid = false;
if (collision == null)
{
//Logger.MsgDebug(" - Collision Null", DebugTypeEnum.Weapon);
}
else
{
if (collision.HasTarget(maxTargetTrajectory))
{
if ((collision.Type == CollisionType.Voxel && !collision.CollisionIsWater) || collision.Type == CollisionType.Safezone)
{
//Logger.MsgDebug(" - Voxel Collision or SafeZone", DebugTypeEnum.Weapon);
hasCollision = true;
}
if (collision.Type == CollisionType.Grid || collision.Type == CollisionType.Shield)
{
hasCollision = true;
collisionIsGrid = true;
bool hostileEntity = collision.GridRelation == TargetRelationEnum.Enemy || collision.ShieldRelation == TargetRelationEnum.Enemy;
if (!hostileEntity && _behavior.AutoPilot.DistanceToCurrentWaypoint > collision.GetCollisionDistance())
{
//Logger.MsgDebug(" - Target On Other Side Of Friendly Grid", DebugTypeEnum.Weapon);
hasCollision = true;
}
if (hostileEntity)
{
collisionCoords = collision.GetCollisionCoords();
hostile = true;
}
}
}
}
if (!canShootWaypoint && !canShootTarget)
{
return(false);
}
if (hasCollision && !hostile)
{
return(false);
}
if (mustContactHostile && !hostile)
{
return(false);
}
return(true);
}
public override void UpdateBeforeSimulation()
{
base.UpdateBeforeSimulation();
try
{
if (cube?.CubeGrid?.Physics == null) //ignore ghost grids
{
return;
}
_currentShootTime = GetLastShootTime();
if (_currentShootTime != _lastShootTime && !_firstUpdate)
{
_isReloading = true;
//fire weapon
if (MyAPIGateway.Multiplayer.IsServer)
{
Vector3D direction;
Vector3D origin;
if (Entity is IMyLargeTurretBase)
{
Vector3D.CreateFromAzimuthAndElevation(turret.Azimuth, turret.Elevation, out direction);
direction = Vector3D.TransformNormal(direction, turret.WorldMatrix);
origin = turret.WorldMatrix.Translation + turret.WorldMatrix.Up * 1.75 + direction * 0.5;
}
else
{
direction = block.WorldMatrix.Forward;
origin = block.WorldMatrix.Translation + direction * -2.5; //for cushion
}
var velocity = block.CubeGrid.Physics.LinearVelocity;
var fireData = new RailgunFireData()
{
ShooterVelocity = velocity,
Origin = origin,
Direction = direction,
ShooterID = Entity.EntityId,
};
RailgunCore.ShootProjectileServer(fireData);
_currentReloadTicks = 0;
//Apply recoil force
var centerOfMass = block.CubeGrid.Physics.CenterOfMassWorld;
var forceVector = -direction * _backkickForce;
block.CubeGrid.Physics.AddForce(MyPhysicsForceType.APPLY_WORLD_IMPULSE_AND_WORLD_ANGULAR_IMPULSE, forceVector, block.GetPosition(), null);
}
}
_lastShootTime = _currentShootTime;
_firstUpdate = false;
ShowReloadMessage();
}
catch (Exception e)
{
MyAPIGateway.Utilities.ShowNotification("Exception in update", 16, MyFontEnum.Red);
MyLog.Default.WriteLine(e);
}
}
