public static void CutOutSphere(BoundingSphere sphere)
{
foreach (MyVoxelMap voxelMap in m_voxelMaps)
{
MyVoxelGenerator.CutOutSphere(voxelMap, sphere);
}
}
private static ulong UpdateVoxelShape(MySyncVoxel sync, PaintType type, MyShape Shape, byte Material)
{
var voxel = sync.Entity as MyVoxelBase;
ulong changedVoxelAmount = 0;
if (voxel != null)
{
switch (type)
{
case PaintType.Paint:
MyVoxelGenerator.PaintInShape(voxel, Shape, Material);
break;
case PaintType.Fill:
changedVoxelAmount = MyVoxelGenerator.FillInShape(voxel, Shape, Material);
break;
case PaintType.Cut:
changedVoxelAmount = MyVoxelGenerator.CutOutShape(voxel, Shape);
break;
}
}
return(changedVoxelAmount);
}
private static bool ResetVoxelInArea(Vector3D Center, float Radius)
{
try
{
BoundingSphereD Sphere = new BoundingSphereD(Center, Radius);
List <MyVoxelBase> Maps = MyEntities.GetEntitiesInSphere(ref Sphere).OfType <MyVoxelBase>().ToList();
if (Maps.Count == 0)
{
return(true);
}
foreach (var voxelMap in Maps)
{
using (voxelMap.Pin())
{
if (voxelMap.MarkedForClose)
{
continue;
}
MyShapeSphere shape = new MyShapeSphere();
shape.Center = Center;
shape.Radius = Radius;
Vector3I minCorner;
Vector3I maxCorner;
Vector3I numCells;
BoundingBoxD shapeAabb = shape.GetWorldBoundaries();
Vector3I StorageSize = voxelMap.Storage.Size;
MyVoxelCoordSystems.WorldPositionToVoxelCoord(voxelMap.PositionLeftBottomCorner, ref shapeAabb.Min, out minCorner);
MyVoxelCoordSystems.WorldPositionToVoxelCoord(voxelMap.PositionLeftBottomCorner, ref shapeAabb.Max, out maxCorner);
minCorner += voxelMap.StorageMin;
maxCorner += voxelMap.StorageMin;
maxCorner += 1;
StorageSize -= 1;
Vector3I.Clamp(ref minCorner, ref Vector3I.Zero, ref StorageSize, out minCorner);
Vector3I.Clamp(ref maxCorner, ref Vector3I.Zero, ref StorageSize, out maxCorner);
numCells = new Vector3I((maxCorner.X - minCorner.X) / 16, (maxCorner.Y - minCorner.Y) / 16, (maxCorner.Z - minCorner.Z) / 16);
minCorner = Vector3I.Max(Vector3I.One, minCorner);
maxCorner = Vector3I.Max(minCorner, maxCorner - Vector3I.One);
voxelMap.Storage.DeleteRange(MyStorageDataTypeFlags.ContentAndMaterial, minCorner, maxCorner, false);
BoundingBoxD cutOutBox = shape.GetWorldBoundaries();
MySandboxGame.Static.Invoke(delegate
{
if (voxelMap.Storage != null)
{
voxelMap.Storage.NotifyChanged(minCorner, maxCorner, MyStorageDataTypeFlags.ContentAndMaterial);
MyVoxelGenerator.NotifyVoxelChanged(MyVoxelBase.OperationType.Revert, voxelMap, ref cutOutBox);
}
}, "RevertShape notify");
}
}
return(true);
}
catch (Exception ex)
{
_log.Error(ex, "Voxel reset failed!");
return(false);
}
}
static void VoxelMeteorCraterSuccess(MySyncVoxel sync, ref MeteorCraterMsg msg, MyNetworkClient sender)
{
var voxel = sync.Entity as MyVoxelBase;
if (voxel != null)
{
MyVoxelGenerator.MakeCrater(voxel, new BoundingSphere(msg.Center, msg.Radius), msg.Normal, MyDefinitionManager.Static.GetVoxelMaterialDefinition(msg.Material));
}
}
void IMyVoxelBase.CreateMeteorCrater(Vector3D center, float radius, Vector3 normal, byte materialIdx)
{
Debug.Assert(Sync.IsServer);
var material = MyDefinitionManager.Static.GetVoxelMaterialDefinition(materialIdx);
if (Sync.IsServer)
{
CreateVoxelMeteorCrater(center, radius, normal, material);
MyVoxelGenerator.MakeCrater(this, new BoundingSphere(center, radius), normal, material);
}
}
protected void CutOutFromVoxel(MyVoxelMap voxelMap, ref BoundingSphere bigSphereForTunnel)
{
if (!IsDummy)
{
if (MyMultiplayerGameplay.IsRunning)
{
MyMultiplayerGameplay.Static.CutOut(voxelMap, ref bigSphereForTunnel);
}
//remove decals
MyDecals.HideTrianglesAfterExplosion(voxelMap, ref bigSphereForTunnel);
//cut off
MyVoxelGenerator.CutOutSphereFast(voxelMap, bigSphereForTunnel);
if (MySession.Is25DSector)
{
// Create debris rocks thrown from the explosion
MyExplosionDebrisVoxel.CreateExplosionDebris(ref bigSphereForTunnel, 1, CommonLIB.AppCode.Networking.MyMwcVoxelMaterialsEnum.Ice_01, MinerWars.AppCode.Game.Managers.Session.MySession.PlayerShip.GroupMask, voxelMap);
BoundingBox boundingBox = BoundingBoxHelper.InitialBox;
BoundingBoxHelper.AddSphere(ref bigSphereForTunnel, ref boundingBox);
// we need local list because this method can be called from inside of the loop
var elements = MyEntities.GetElementsInBox(ref boundingBox);
foreach (var el in elements)
{
MyEntity entity = ((MinerWars.AppCode.Game.Physics.MyPhysicsBody)el.GetRigidBody().m_UserData).Entity;
MyExplosionDebrisVoxel debris = entity as MyExplosionDebrisVoxel;
if (debris == null)
{
continue;
}
Vector3 awayDirection = debris.GetPosition() - bigSphereForTunnel.Center;
debris.Physics.AddForce(
MinerWars.AppCode.Game.Physics.MyPhysicsForceType.APPLY_WORLD_IMPULSE_AND_WORLD_ANGULAR_IMPULSE,
awayDirection * MyExplosionsConstants.EXPLOSION_FORCE_RADIUS_MULTIPLIER * 100000,
bigSphereForTunnel.Center,
MinerWars.CommonLIB.AppCode.Utils.MyMwcUtils.GetRandomVector3Normalized() * 10000);
}
elements.Clear();
}
PlayVoxelCutCue();
}
}
void OnCutOut(ref MyEventCutOut msg)
{
MyVoxelMap voxelMap;
if (MyEntities.TryGetEntityById <MyVoxelMap>(msg.VoxelMapEntityId.ToEntityId(), out voxelMap))
{
var sphere = new BoundingSphere(msg.Position, msg.Radius);
//remove decals
MyDecals.HideTrianglesAfterExplosion(voxelMap, ref sphere);
//cut off
MyVoxelGenerator.CutOutSphereFast(voxelMap, sphere);
}
}
private void CreateCrater(MyPhysics.MyContactPointEvent value, MyVoxelBase voxel)
{
if (Math.Abs(Vector3.Normalize(-Entity.WorldMatrix.Forward).Dot(value.ContactPointEvent.ContactPoint.Normal)) < 0.1)
{
MyParticleEffect impactParticle1;
if (InParticleVisibleRange && MyParticlesManager.TryCreateParticleEffect("Meteorit_Smoke1AfterHit", out impactParticle1))
{
impactParticle1.WorldMatrix = Entity.WorldMatrix;
impactParticle1.UserScale = (float)Entity.PositionComp.WorldVolume.Radius * 2;
}
m_particleVectorUp = Vector3.Zero;
m_closeAfterSimulation = Sync.IsServer;
return;
}
if (Sync.IsServer)
{
float craterRadius = Entity.PositionComp.Scale.Value * 5;
BoundingSphereD sphere = new BoundingSphere(value.Position, craterRadius);
Vector3 direction;
// if contact was send after reflection we need to get former direction
if (value.ContactPointEvent.SeparatingVelocity < 0)
{
direction = Vector3.Normalize(Entity.Physics.LinearVelocity);
}
else
{
direction = Vector3.Normalize(Vector3.Reflect(Entity.Physics.LinearVelocity, value.ContactPointEvent.ContactPoint.Normal));
}
var material = VoxelMaterial;
int tries = MyDefinitionManager.Static.GetVoxelMaterialDefinitions().Count() * 2; // max amount of tries
while (!material.IsRare || !material.SpawnsFromMeteorites || material.MinVersion > MySession.Static.Settings.VoxelGeneratorVersion)
{
if (--tries < 0) // to prevent infinite loops in case all materials are disabled just use the meteorites' initial material
{
material = VoxelMaterial;
break;
}
material = MyDefinitionManager.Static.GetVoxelMaterialDefinitions().ElementAt(MyUtils.GetRandomInt(MyDefinitionManager.Static.GetVoxelMaterialDefinitions().Count() - 1));
}
voxel.CreateVoxelMeteorCrater(sphere.Center, (float)sphere.Radius, -direction, material);
MyVoxelGenerator.MakeCrater(voxel, sphere, -direction, material);
}
m_soundEmitter.Entity = voxel as MyEntity;
m_soundEmitter.SetPosition(Entity.PositionComp.GetPosition());
m_closeAfterSimulation = Sync.IsServer;
}
protected virtual bool TryDrillVoxels(MyVoxelBase voxels, Vector3D hitPosition, bool collectOre, bool onlyCheck, bool applyDamagedMaterial)
{
const float DISCARDING_MULTIPLIER = 3.0f;
if (voxels.GetOrePriority() == MyVoxelConstants.PRIORITY_IGNORE_EXTRACTION)
{
return(false);
}
bool somethingDrilled = false;
var bsphere = new MyShapeSphere()
{
Center = m_cutOut.Sphere.Center,
Radius = (float)m_cutOut.Sphere.Radius
};
if (!collectOre)
{
bsphere.Radius *= DISCARDING_MULTIPLIER;
}
float voxelsCountInPercent;
MyVoxelMaterialDefinition material;
MyVoxelGenerator.CutOutShapeWithProperties(voxels, bsphere,
out voxelsCountInPercent, out material, m_drilledMaterialBuffer, Sync.IsServer, onlyCheck, applyDamagedMaterial);
foreach (var entry in m_drilledMaterialBuffer)
{
somethingDrilled = (!collectOre || TryHarvestOreMaterial(entry.Key, hitPosition, entry.Value, onlyCheck)) || somethingDrilled;
if (somethingDrilled && !onlyCheck)
{
MyDebris.Static.CreateDirectedDebris(hitPosition,
MyUtils.GetRandomVector3Normalized(), 0.1f, 1, 0, MathHelper.Pi, 5, 1, 0.15f, entry.Key);
}
}
m_drilledMaterialBuffer.Clear();
return(somethingDrilled);
}
private ulong UpdateVoxelShape(OperationType type, MyShape shape, byte Material)
{
ulong changedVoxelAmount = 0;
switch (type)
{
case OperationType.Paint:
MyVoxelGenerator.PaintInShape(this, shape, Material);
break;
case OperationType.Fill:
changedVoxelAmount = MyVoxelGenerator.FillInShape(this, shape, Material);
break;
case OperationType.Cut:
changedVoxelAmount = MyVoxelGenerator.CutOutShape(this, shape);
break;
}
return(changedVoxelAmount);
}
private void CreateCrater(MyPhysics.MyContactPointEvent value, MyVoxelMap voxel)
{
if (Math.Abs(Vector3.Normalize(-Entity.WorldMatrix.Forward).Dot(value.ContactPointEvent.ContactPoint.Normal)) < 0.1)
{
MyParticleEffect impactParticle1;
if (InParticleVisibleRange && MyParticlesManager.TryCreateParticleEffect((int)MyParticleEffectsIDEnum.MeteorAsteroidCollision, out impactParticle1))
{
impactParticle1.WorldMatrix = Entity.WorldMatrix;
impactParticle1.UserScale = (float)Entity.PositionComp.WorldVolume.Radius * 2;
}
m_particleVectorUp = Vector3.Zero;
return;
}
if (Sync.IsServer)
{
BoundingSphereD sphere = new BoundingSphere(value.Position, Entity.PositionComp.Scale.Value / 3);
Vector3 direction;
// if contact was send after reflection we need to get former direction
if (value.ContactPointEvent.SeparatingVelocity < 0)
{
direction = Vector3.Normalize(Entity.Physics.LinearVelocity);
}
else
{
direction = Vector3.Normalize(Vector3.Reflect(Entity.Physics.LinearVelocity, value.ContactPointEvent.ContactPoint.Normal));
}
var material = VoxelMaterial;
while (!material.IsRare)
{
material = MyDefinitionManager.Static.GetVoxelMaterialDefinitions().ElementAt(MyUtils.GetRandomInt(MyDefinitionManager.Static.GetVoxelMaterialDefinitions().Count() - 1));
}
voxel.SyncObject.CreateVoxelMeteorCrater(sphere.Center, (float)sphere.Radius, -direction, material);
MyVoxelGenerator.MakeCrater(voxel, sphere, -direction, material);
}
m_closeAfterSimulation = true;
}
private void CreateVoxelMeteorCrater_Implementation(Vector3D center, float radius, Vector3 normal, byte material)
{
MyVoxelGenerator.MakeCrater(this, new BoundingSphere(center, radius), normal, MyDefinitionManager.Static.GetVoxelMaterialDefinition(material));
}
/// <summary>
/// Starts the explosion.
/// </summary>
/// <param name="damage"></param>
/// <param name="type"></param>
/// <param name="explosionSphere"></param>
/// <param name="lifespanInMiliseconds"></param>
/// <param name="explosionForceDirection"></param>
/// <param name="groupMask"></param>
/// <param name="createExplosionDebris"></param>
/// <param name="cascadeLevel"></param>
/// <param name="hitEntity"></param>
/// <param name="particleScale"></param>
/// <param name="ownerEntity"></param>
/// <param name="affectVoxels"></param>
/// <param name="applyForceAndDamage"></param>
/// <param name="createDecals"></param>
/// <param name="direction">If applicable, gives the direction of the explosion, e.g. when it was caused by a missile (with its moving direction).</param>
public void Start(ref MyExplosionInfo explosionInfo)
{
//MyCommonDebugUtils.AssertDebug(explosionInfo.ExplosionSphere.Radius <= MyExplosionsConstants.EXPLOSION_RADIUS_MAX);
MyCommonDebugUtils.AssertDebug(explosionInfo.ExplosionSphere.Radius > 0);
MyRender.GetRenderProfiler().StartProfilingBlock("MyExplosion.Start");
m_explosionSphere = explosionInfo.ExplosionSphere;
m_elapsedMiliseconds = 0;
m_lifespanInMiliseconds = explosionInfo.LifespanMiliseconds;
if (explosionInfo.PlaySound)
{
MyRender.GetRenderProfiler().StartProfilingBlock("Sound");
// Play explosion sound
if (m_explosionCue != null && m_explosionCue.Value.IsPlaying)
{
m_explosionCue.Value.Stop(SharpDX.XACT3.StopFlags.Immediate);
}
m_explosionCue = MyAudio.AddCue3D(GetCueEnumByExplosionType(explosionInfo.ExplosionType), m_explosionSphere.Center, Vector3.Zero, Vector3.Zero, Vector3.Zero);
MyRender.GetRenderProfiler().EndProfilingBlock();
}
MyRender.GetRenderProfiler().StartProfilingBlock("Light");
// Light of explosion
/*
* m_light = MyLights.AddLight();
* if (m_light != null)
* {
* m_light.Start(MyLight.LightTypeEnum.PointLight, m_explosionSphere.Center, MyExplosionsConstants.EXPLOSION_LIGHT_COLOR, 1, Math.Min(m_explosionSphere.Radius * 8.0f, MyLightsConstants.MAX_POINTLIGHT_RADIUS));
* m_light.Intensity = 2.0f;
* } */
MyRender.GetRenderProfiler().EndProfilingBlock();
// close explosion check
bool close = IsExplosionClose(explosionInfo.ExplosionSphere);
MyParticleEffectsIDEnum newParticlesType;
switch (explosionInfo.ExplosionType)
{
case MyExplosionTypeEnum.SMALL_SHIP_EXPLOSION:
// Create metal debris objects thrown from the explosion
// This must be called before ApplyExplosionForceAndDamage (because there we apply impulses to the debris)
// Throw a lot of debrises, more than only if some metalic object is hit (because this is destruction of a ship)
//MyPhysObjectExplosionDebrises.CreateExplosionDebris(m_explosionSphere.Center, 1);
newParticlesType = MyParticleEffectsIDEnum.Explosion_Smallship;
break;
case MyExplosionTypeEnum.MISSILE_EXPLOSION:
newParticlesType =
// ? MyParticleEffectsIDEnum.Explosion_Missile_Close
MyParticleEffectsIDEnum.Explosion_Missile;
break;
case MyExplosionTypeEnum.BOMB_EXPLOSION:
case MyExplosionTypeEnum.GRAVITY_EXPLOSION:
newParticlesType = MyParticleEffectsIDEnum.Explosion_Bomb;
break;
case MyExplosionTypeEnum.AMMO_EXPLOSION:
newParticlesType = MyParticleEffectsIDEnum.Explosion_Ammo;
break;
case MyExplosionTypeEnum.BLASTER_EXPLOSION:
newParticlesType = MyParticleEffectsIDEnum.Explosion_Blaster;
break;
case MyExplosionTypeEnum.BIOCHEM_EXPLOSION:
newParticlesType = MyParticleEffectsIDEnum.Explosion_BioChem;
break;
case MyExplosionTypeEnum.EMP_EXPLOSION:
case MyExplosionTypeEnum.FLASH_EXPLOSION:
newParticlesType = MyParticleEffectsIDEnum.Explosion_EMP;
break;
case MyExplosionTypeEnum.METEOR_EXPLOSION:
newParticlesType = MyParticleEffectsIDEnum.Explosion_Meteor;
break;
case MyExplosionTypeEnum.NUCLEAR_EXPLOSION:
newParticlesType = MyParticleEffectsIDEnum.Explosion_Nuclear;
break;
case MyExplosionTypeEnum.PLASMA_EXPLOSION:
newParticlesType = MyParticleEffectsIDEnum.Explosion_Plasma;
break;
case MyExplosionTypeEnum.SMALL_EXPLOSION:
newParticlesType = MyParticleEffectsIDEnum.Explosion_SmallPrefab;
break;
case MyExplosionTypeEnum.LARGE_SHIP_EXPLOSION:
newParticlesType = MyParticleEffectsIDEnum.Explosion_Huge;
break;
case MyExplosionTypeEnum.LARGE_PREFAB_EXPLOSION:
newParticlesType = MyParticleEffectsIDEnum.Explosion_Large;
break;
case MyExplosionTypeEnum.MEDIUM_PREFAB_EXPLOSION:
newParticlesType = MyParticleEffectsIDEnum.Explosion_Medium;
break;
case MyExplosionTypeEnum.ASTEROID_EXPLOSION:
newParticlesType = MyParticleEffectsIDEnum.Explosion_Asteroid;
break;
default:
throw new System.NotImplementedException();
break;
}
if (explosionInfo.Damage > 0)
{
MyRender.GetRenderProfiler().StartProfilingBlock("Voxel or collision");
// If explosion sphere intersects a voxel map, we need to cut out a sphere, spawn debrises, etc
MyVoxelMap voxelMap = explosionInfo.AffectVoxels && explosionInfo.EmpDamage == 0 ? MyVoxelMaps.GetOverlappingWithSphere(ref m_explosionSphere) : null;
if (voxelMap != null)
{
// Dirty explosion with a lot of dust
MyMwcVoxelMaterialsEnum?voxelMaterial = null;
float voxelContentRemovedInPercent = 0;
bool createDebris = true; // We want to create debris
if (explosionInfo.HitEntity != null) // but not when we hit prefab
{
createDebris &= explosionInfo.HitEntity is MyVoxelMap;
}
//cut off
BoundingSphere voxelExpSphere = new BoundingSphere(explosionInfo.VoxelExplosionCenter, m_explosionSphere.Radius * explosionInfo.VoxelCutoutScale);
if (MyVoxelGenerator.CutOutSphereFast(voxelMap, voxelExpSphere, out voxelContentRemovedInPercent, out voxelMaterial, (explosionInfo.OwnerEntity is MySmallShip && explosionInfo.OwnerEntity == Managers.Session.MySession.PlayerShip), MyFakes.VOXELS_REMOVE_RATIO))
{
if (explosionInfo.HitEntity is MyVoxelMap)
{
HUD.MyHud.ShowIndestructableAsteroidNotification();
}
createDebris = false; // and no debris when voxel is indestructible
}
// Only if at least something was removed from voxel map
// If voxelContentRemovedInPercent is more than zero than also voxelMaterial shouldn't be null, but I rather check both of them.
if ((voxelContentRemovedInPercent > 0) && (voxelMaterial != null))
{
//remove decals
MyDecals.HideTrianglesAfterExplosion(voxelMap, ref voxelExpSphere);
MyRender.GetRenderProfiler().StartProfilingBlock("CreateDebris");
if (explosionInfo.CreateDebris && (createDebris || explosionInfo.ForceDebris) && MyRenderConstants.RenderQualityProfile.ExplosionDebrisCountMultiplier > 0)
{
// Create debris rocks thrown from the explosion
// This must be called before ApplyExplosionForceAndDamage (because there we apply impulses to the debris)
MyExplosionDebrisVoxel.CreateExplosionDebris(ref voxelExpSphere, voxelContentRemovedInPercent, voxelMaterial.Value, explosionInfo.GroupMask, voxelMap);
}
MyRender.GetRenderProfiler().EndProfilingBlock();
MyRender.GetRenderProfiler().StartProfilingBlock("CreateParticleEffect");
MyParticleEffect explosionEffect = MyParticlesManager.CreateParticleEffect((int)MyParticleEffectsIDEnum.MaterialExplosion_Destructible);
explosionEffect.WorldMatrix = Matrix.CreateTranslation(voxelExpSphere.Center);
explosionEffect.UserRadiusMultiplier = voxelExpSphere.Radius;
MyRender.GetRenderProfiler().EndProfilingBlock();
}
}
MyRender.GetRenderProfiler().EndProfilingBlock();
}
if (explosionInfo.Damage > 0)
{
// Create dirt decals in player's cockpit glass
MyRender.GetRenderProfiler().StartProfilingBlock("Cockpit Decals");
CreateDirtDecalOnCockpitGlass(ref m_explosionSphere);
MyRender.GetRenderProfiler().EndProfilingBlock();
}
if (DEBUG_EXPLOSIONS)
{
MyRender.GetRenderProfiler().EndProfilingBlock();
return;
}
if (explosionInfo.Damage > 0)
{
BoundingSphere influenceExplosionSphere = m_explosionSphere;
influenceExplosionSphere.Radius *= MyExplosionsConstants.EXPLOSION_RADIUS_MULTPLIER_FOR_IMPULSE;
for (int i = 0; i < explosionInfo.CascadeLevel; i++)
{
influenceExplosionSphere.Radius *= MyExplosionsConstants.EXPLOSION_CASCADE_FALLOFF;
}
// Throws surrounding objects away from centre of the explosion.
if (explosionInfo.ApplyForceAndDamage)
{
if (explosionInfo.ExplosionType == MyExplosionTypeEnum.LARGE_PREFAB_EXPLOSION ||
explosionInfo.ExplosionType == MyExplosionTypeEnum.LARGE_SHIP_EXPLOSION ||
explosionInfo.ExplosionType == MyExplosionTypeEnum.MEDIUM_PREFAB_EXPLOSION)
{
DisableContainedDummyParticles(ref explosionInfo);
}
explosionInfo.StrengthImpulse = MyExplosionsConstants.EXPLOSION_STRENGTH_IMPULSE * m_explosionSphere.Radius / 20;
explosionInfo.StrengthAngularImpulse = MyExplosionsConstants.EXPLOSION_STRENGTH_ANGULAR_IMPULSE;
explosionInfo.HitEntity = explosionInfo.HitEntity != null?explosionInfo.HitEntity.GetBaseEntity() : null;
MyRender.GetRenderProfiler().StartProfilingBlock("ApplyExplosionForceAndDamage");
MyEntities.ApplyExplosionForceAndDamage(ref explosionInfo);
MyRender.GetRenderProfiler().EndProfilingBlock();
}
// Look for objects in explosion radius
BoundingBox boundingBox;
BoundingBox.CreateFromSphere(ref influenceExplosionSphere, out boundingBox);
//if (explosionInfo.CreateDecals && explosionInfo.Direction.HasValue && explosionInfo.EmpDamage == 0)
//{
// CreateDecals(explosionInfo.Direction.Value);
//}
}
if (explosionInfo.CreateParticleEffect)
{
MyRender.GetRenderProfiler().StartProfilingBlock("Particles");
if (explosionInfo.CustomEffect != null)
{
if (explosionInfo.CustomEffect.ParticleID == 0)
{
explosionInfo.CustomEffect.ParticleID = (int)newParticlesType;
}
//Reload effect
explosionInfo.CustomEffect.Enabled = false;
explosionInfo.CustomEffect.Enabled = true;
}
else
{
// Explosion particles
GenerateExplosionParticles(newParticlesType, m_explosionSphere, explosionInfo.ParticleScale);
}
MyRender.GetRenderProfiler().EndProfilingBlock();
}
MyRender.GetRenderProfiler().EndProfilingBlock();
/*
* // When MyAmmoBase entity is closed to explosion it will explode
* if (entity is MyAmmoBase)
* {
* (entity as MyAmmoBase).ExplodeCascade(cascadeLevel + 1);
* }
*/
// Smut decals - must be called after the explosion, after voxels are cutted out
/*if ((intersection.PhysObject is MyVoxelMap) == false)
* {
* if (intersection.PhysObject is MyCockpitGlass)
* {
* // Change phys object so rest of the code will think we hit the parent
* // Same fix is in projectile too - because cockpit glass is only helper object, we don't use it for real rendering and stuff
* // And if not changed, it can make problem in "phys object decals"
* intersection.PhysObject = intersection.PhysObject.Parent;
* }
*
* // Create explosion smut decal on model we hit by this missile
* MyDecals.Add(
* MyDecalTexturesEnum.ExplosionSmut,
* MyMwcUtils.GetRandomFloat(m_explosionSphere.Radius * 0.7f, m_explosionSphere.Radius * 1.3f),
* MyMwcUtils.GetRandomRadian(),
* GetSmutDecalRandomColor(),
* true,
* ref intersection);
* }
* else
* {
* // Creating explosion smut decal on voxel is more complicated than on voxel. We will project few lines
* // from explosion epicentrum to the surounding world (random directions) and place decal where intersection detected.
* //if (knownMissileDirection != null)
* //{
* // MyLine linePrologned = new MyLine(knownIntersection.Value.IntersectionPointInObjectSpace,
* // knownIntersection.Value.IntersectionPointInObjectSpace + knownMissileDirection.Value * MyExplosionsConstants.EXPLOSION_RANDOM_RADIUS_MAX * 2,
* // true);
* // MyLineTriangleIntersectionResult intersectionForSmut = knownIntersection.Value.VoxelMap.GetIntersectionWithLine(ref linePrologned);
* // if (intersectionForSmut.Found == true)
* // {
* // MyDecals.Add(
* // MyDecalTexturesEnum.ExplosionSmut,
* // MyMwcUtils.GetRandomFloat(m_explosionSphere.Radius * 0.5f, m_explosionSphere.Radius * 1.0f),
* // MyMwcUtils.GetRandomRadian(),
* // GetSmutDecalRandomColor(),
* // false,
* // ref intersectionForSmut);
* // }
* //}
* }*/
// Generate dust particles that will stay in place of the explosion
//doesnt look good in final
//GenerateStatisDustParticles(m_explosionSphere);
}
// Called when we finished harvesting current voxel
void StartReleaseVoxel()
{
if (m_parentMinerShip == null || m_parentMinerShip.IsDead() || m_parentMinerShip.Inventory == null)
{
return;
}
StartImplodeCue();
BoundingSphere explosion = new BoundingSphere(m_headPositionTransformed, MyVoxelConstants.VOXEL_SIZE_IN_METRES * 1);
//remove decals
MyDecals.HideTrianglesAfterExplosion(m_inVoxelMap, ref explosion);
//cut off
var minedMaterialsWithContents = MyVoxelGenerator.CutOutSphereFastWithMaterials(m_inVoxelMap, explosion);
var dustEffect = MyParticlesManager.CreateParticleEffect((int)MyParticleEffectsIDEnum.Harvester_Finished);
dustEffect.WorldMatrix = Matrix.CreateTranslation(m_headPositionTransformed);
bool hudHarvestingCompletePlayed = false;
bool harvestingFinishedAsyncSent = false;
var minedOres = new Dictionary <int, float>();
foreach (var minedMaterialWithContent in minedMaterialsWithContents)
{
MyOreRatioFromVoxelMaterial[] oreFromVoxel = MyVoxelMapOreMaterials.GetOreFromVoxelMaterial(minedMaterialWithContent.Key);
if (oreFromVoxel != null && this.Parent == MySession.PlayerShip)
{
// accumulate amounts of the same type
foreach (MyOreRatioFromVoxelMaterial oreRatio in oreFromVoxel)
{
float amount = minedMaterialWithContent.Value * oreRatio.Ratio * MyHarvestingTubeConstants.MINED_CONTENT_RATIO;
float oldAmount = 0;
minedOres.TryGetValue((int)oreRatio.OreType, out oldAmount);
minedOres[(int)oreRatio.OreType] = amount + oldAmount;
}
if (!harvestingFinishedAsyncSent)
{
try
{
// Disabled, still unused on server
//var client = MySectorServiceClient.GetCheckedInstance();
//client.HarvestingFinishedAsync(minedMaterialWithContent.Key, (byte)(minedMaterialWithContent.Value * MyVoxelConstants.VOXEL_CONTENT_FULL_FLOAT));
}
catch (Exception)
{
Debug.Fail("Cannot send harvesting to server");
}
harvestingFinishedAsyncSent = true;
}
if (!hudHarvestingCompletePlayed)
{
hudHarvestingCompletePlayed = true;
MyAudio.AddCue2D(MySoundCuesEnum.HudHarvestingComplete);
}
}
}
bool inventoryFullWarningPlayed = false;
// add ores to inventory
foreach (var ore in minedOres)
{
float amountLeft = m_parentMinerShip.Inventory.AddInventoryItem(MyMwcObjectBuilderTypeEnum.Ore, ore.Key, ore.Value, false);
float amountAdded = ore.Value - amountLeft;
if (amountAdded > 0f)
{
MyHudNotification.AddNotification(new MyHudNotification.MyNotification(MyTextsWrapperEnum.HarvestNotification, 3500, textFormatArguments: new object[]
{
amountAdded,
((MyGuiOreHelper)MyGuiObjectBuilderHelpers.GetGuiHelper(MyMwcObjectBuilderTypeEnum.Ore, ore.Key)).Name
}
));
}
if (amountLeft > 0f)
{
MyHudNotification.AddNotification(new MyHudNotification.MyNotification(MyTextsWrapperEnum.HarvestNotificationInventoryFull, MyGuiManager.GetFontMinerWarsRed(), 3500,
textFormatArguments: new object[]
{
amountLeft,
((MyGuiOreHelper)MyGuiObjectBuilderHelpers.GetGuiHelper(MyMwcObjectBuilderTypeEnum.Ore, ore.Key)).Name
}
));
if (!inventoryFullWarningPlayed)
{
MyAudio.AddCue2D(MySoundCuesEnum.HudInventoryFullWarning);
inventoryFullWarningPlayed = true;
}
}
}
StartReturningBack();
}
private static void VoxelPlacement()
{
var camera = MySector.MainCamera;
if (camera == null)
{
return;
}
var offset = 0; // MyVoxelConstants.VOXEL_SIZE_IN_METRES_HALF;
var targetPosition = camera.Position + (Vector3D)camera.ForwardVector * 4.5f - offset;
MyVoxelBase targetVoxelMap = null;
foreach (var voxelMap in MySession.Static.VoxelMaps.Instances)
{
if (voxelMap.PositionComp.WorldAABB.Contains(targetPosition) == ContainmentType.Contains)
{
targetVoxelMap = voxelMap;
break;
}
}
if (targetVoxelMap == null)
{
return;
}
Vector3I targetVoxel;
MyVoxelCoordSystems.WorldPositionToVoxelCoord(targetVoxelMap.PositionLeftBottomCorner, ref targetPosition, out targetVoxel);
MyVoxelCoordSystems.VoxelCoordToWorldPosition(targetVoxelMap.PositionLeftBottomCorner, ref targetVoxel, out targetPosition);
targetPosition += offset;
var size = 3.0f;
const int shapeType = 0;
{
BoundingBoxD aabb;
MyVoxelCoordSystems.VoxelCoordToWorldAABB(targetVoxelMap.PositionLeftBottomCorner, ref targetVoxel, out aabb);
VRageRender.MyRenderProxy.DebugDrawAABB(aabb, Color.Blue, 1f, 1f, true);
}
BoundingSphereD sphere;
BoundingBoxD box;
if (shapeType == 0)
{
sphere = new BoundingSphereD(targetPosition, size * 0.5f);
VRageRender.MyRenderProxy.DebugDrawSphere(targetPosition, size * 0.5f, Color.White, 1f, true);
}
else if (shapeType == 1)
{
box = new BoundingBoxD(
targetPosition - size * 0.5f,
targetPosition + size * 0.5f);
VRageRender.MyRenderProxy.DebugDrawAABB(box, Color.White, 1f, 1f, true);
}
else if (shapeType == 2)
{
MyVoxelCoordSystems.WorldPositionToVoxelCoord(targetVoxelMap.PositionLeftBottomCorner, ref targetPosition, out targetVoxel);
//targetVoxel = Vector3I.Zero;
MyVoxelCoordSystems.VoxelCoordToWorldAABB(targetVoxelMap.PositionLeftBottomCorner, ref targetVoxel, out box);
VRageRender.MyRenderProxy.DebugDrawAABB(box, Vector3.One, 1f, 1f, true);
}
bool leftPressed = MyInput.Static.IsLeftMousePressed();
if (leftPressed)
{
MyShape shape;
if (shapeType == 0)
{
shape = new MyShapeSphere()
{
Center = sphere.Center,
Radius = (float)sphere.Radius,
};
}
else if (shapeType == 1 || shapeType == 2)
{
shape = new MyShapeBox()
{
Boundaries = box,
};
}
if (shape != null)
{
float dummy;
MyVoxelMaterialDefinition dummy2;
MyVoxelGenerator.CutOutShapeWithProperties(targetVoxelMap, shape, out dummy, out dummy2);
}
}
}
void IMyVoxelMaps.FillInShape(IMyVoxelBase voxelMap, IMyVoxelShape voxelShape, byte materialIdx)
{
MyVoxelGenerator.RequestFillInShape(voxelMap, voxelShape, materialIdx);
}
void IMyVoxelMaps.CutOutShape(IMyVoxelBase voxelMap, IMyVoxelShape voxelShape)
{
MyVoxelGenerator.RequestCutOutShape(voxelMap, voxelShape);
}
void IMyVoxelMaps.MakeCrater(IMyVoxelBase voxelMap, BoundingSphereD sphere, Vector3 normal, byte materialIdx)
{
var material = MyDefinitionManager.Static.GetVoxelMaterialDefinition(materialIdx);
MyVoxelGenerator.MakeCrater((MyVoxelBase)voxelMap, sphere, normal, material);
}
