private List<Shop_Store> BuildTestData()
{
List<Shop_Store> stores = new List<Shop_Store>();
for (int i = 0; i < 100; i++)
{
Account_Period ap = new Account_Period();
ap.AccountID = Guid.NewGuid();
ap.BeginDate = DateTime.Now;
ap.EndDate = DateTime.Now;
ProInfo pi = new ProInfo();
pi.Name = "name" + i;
pi.Unit = "jin";
ShopInfo si = new ShopInfo();
si.ShopName = "name" + i;
Shop_Store ss = new Shop_Store();
ss.Account_Period = ap;
ss.ChkQty = i;
ss.CurrQty = i;
ss.ExpQty = i;
ss.Id = i;
ss.ImpQty = ss.PreQty = i;
ss.ProInfo = pi;
ss.ShopInfo = si;
stores.Add(ss);
}
return stores;
}
protected void btnSave_Click(object sender, EventArgs e)
{
ProInfo pro;
if (proid == null)
{
pro = new ProInfo();
}
else
{
pro = dpi.GetByProID(new Guid(proid));
}
pro.Unit = tbUnit.Text;
pro.ProCate = string.IsNullOrEmpty(tbProCate.Text) ? ddlProCate.SelectedValue : tbProCate.Text;
pro.Name = tbName.Text;
pro.Memo = tbMemo.Text;
pro.PicName = UpLoadFile1.FileName;
Guid pid = dpi.Save(pro);
if (proid == null)
{
Session[WebHint.Web_Hint] = new WebHint("保存成功", "/Product/edit.aspx?proid=" + pid, HintFlag.跳转);
}
else
{
Session[WebHint.Web_Hint] = new WebHint("保存成功", "/Product/Default.aspx", HintFlag.跳转);
}
Response.Redirect(WebHint.HintURL);
}
protected void Page_Load(object sender, EventArgs e)
{
proid = Request["ProID"];
CurrentProInfo = dpi.GetByProID(new Guid(proid));
if (!IsPostBack)
{
BindProCate();
BindProInfo();
BindLimit();
}
}
public static string Descrypt(string Content, string format = null)
{
if (string.IsNullOrEmpty(Content))
{
return(string.Empty);
}
string ResContent = string.Empty;
string className = string.Empty;
string[] temp = Content.Split("\r\n".ToCharArray());
List <string> realtemp = new List <string>();
List <ProInfo> pros = new List <ProInfo>();
//过滤非类名，非属性代码
foreach (string item in temp)
{
if (item.Contains("private") || item.Contains(@"//") || item.Contains("class"))
{
realtemp.Add(item.Trim());
}
}
if (realtemp.Count == 0)
{
return(string.Empty);
}
//修正在代码行上面注释的代码
for (int i = 0; i < realtemp.Count; i++)
{
if (!realtemp[i].Contains("class") && !(realtemp[i].Contains("private") && realtemp[i].Contains(@"//")))
{
if (realtemp[i].Contains("private") && i - 1 >= 0 && realtemp[i - 1].Contains(@"//"))
{
realtemp[i] = realtemp[i].Trim() + realtemp[i - 1].Trim();
}
}
}
//类名加工
foreach (var item in realtemp)
{
Regex reg = new Regex(@"\s?public\s?class\s(\w+)\s.*");
GroupCollection result = reg.Match(item).Groups;
className = result[1].ToString();
if (!string.IsNullOrEmpty(className))
{
break;
}
}
//属性加工
foreach (var item in realtemp)
{
if (item.Contains("private") && item.Contains(@"//"))
{
Regex reg = new Regex(@"\s?(private)\s?(\w+<?\w+>?)\s(\w+)\s?(=?.*);\s?//\s?(.*)");
GroupCollection result = reg.Match(item).Groups;
ProInfo info = new ProInfo()
{
Name = result[3].ToString(),
Opening = result[1].ToString(),
Typer = result[2].ToString(),
Notes = result[5].ToString(),
DefaultValue = result[4].ToString()
};
pros.Add(info);
}
}
//属性代码生成
foreach (var item in pros)
{
string res = string.Empty;
try
{
if (string.IsNullOrEmpty(format))
{
res = string.Format(@"
/// <summary>
/// {0}
/// </summary>
private {1} _{2} {4};
/// <summary>
/// 获取或设置{0}
/// </summary>
public {1} {3}
{{
get {{ return _{2}; }}
set {{ _{2} = value;}}
}}
", item.Notes, item.Typer, item.Name, UpperFirst(item.Name), item.DefaultValue);
}
else
{
res = string.Format(format, item.Notes, item.Typer, item.Name, UpperFirst(item.Name), item.DefaultValue);
}
//替换ArrayList为List
res = res.Replace("ArrayList", "List");
}
catch (Exception)
{ }
ResContent += res;
}
//生成类名
if (!string.IsNullOrEmpty(className))
{
ResContent = string.Format(@"public class {0}
{{
{1}
}}", UpperFirst(className), ResContent);
}
return(ResContent);
}
private void UpdateEffect(HitEntity hitEnt, ProInfo info)
{
var grid = hitEnt.Entity as MyCubeGrid;
if (grid == null || grid.MarkedForClose)
{
return;
}
Dictionary <AreaEffectType, GridEffect> effects;
var attackerId = info.AmmoDef.DamageScales.Shields.Type == ShieldDef.ShieldType.Bypass ? grid.EntityId : info.Target.FiringCube.EntityId;
var found = false;
if (_gridEffects.TryGetValue(grid, out effects))
{
GridEffect gridEffect;
if (effects.TryGetValue(info.AmmoDef.AreaEffect.AreaEffect, out gridEffect))
{
found = true;
gridEffect.Damage += info.AreaEffectDamage;
gridEffect.Ai = info.Ai;
gridEffect.AttackerId = attackerId;
gridEffect.Hits++;
if (hitEnt.HitPos != null)
{
gridEffect.HitPos = hitEnt.HitPos.Value / gridEffect.Hits;
}
}
}
if (!found)
{
if (effects == null)
{
effects = GridEffectsPool.Get();
}
GridEffect gridEffect;
if (effects.TryGetValue(info.AmmoDef.AreaEffect.AreaEffect, out gridEffect))
{
gridEffect.Damage += info.AreaEffectDamage;
gridEffect.Ai = info.Ai;
gridEffect.AmmoDef = info.AmmoDef;
gridEffect.AttackerId = attackerId;
gridEffect.Hits++;
if (hitEnt.HitPos != null)
{
gridEffect.HitPos += hitEnt.HitPos.Value / gridEffect.Hits;
}
}
else
{
gridEffect = GridEffectPool.Get();
gridEffect.System = info.System;
gridEffect.Damage = info.AreaEffectDamage;
gridEffect.Ai = info.Ai;
gridEffect.AmmoDef = info.AmmoDef;
gridEffect.AttackerId = attackerId;
gridEffect.Hits++;
if (hitEnt.HitPos != null)
{
gridEffect.HitPos = hitEnt.HitPos.Value;
}
effects.Add(info.AmmoDef.AreaEffect.AreaEffect, gridEffect);
}
_gridEffects.Add(grid, effects);
}
info.BaseHealthPool = 0;
info.BaseDamagePool = 0;
}
private void DamageShield(HitEntity hitEnt, ProInfo info)
{
var shield = hitEnt.Entity as IMyTerminalBlock;
if (shield == null || !hitEnt.HitPos.HasValue)
{
return;
}
info.ObjectsHit++;
var damageScale = 1;
var fallOff = info.AmmoDef.Const.FallOffScaling && info.DistanceTraveled > info.AmmoDef.DamageScales.FallOff.Distance;
if (info.AmmoDef.Const.VirtualBeams)
{
damageScale *= info.WeaponCache.Hits;
}
var damageType = info.AmmoDef.DamageScales.Shields.Type;
var energy = damageType == ShieldDef.ShieldType.Energy;
var heal = damageType == ShieldDef.ShieldType.Heal;
var shieldByPass = info.AmmoDef.DamageScales.Shields.Type == ShieldDef.ShieldType.Bypass;
var areaEffect = info.AmmoDef.AreaEffect;
var detonateOnEnd = info.AmmoDef.AreaEffect.Detonation.DetonateOnEnd && areaEffect.AreaEffect != AreaEffectType.Disabled && !shieldByPass;
var areaDamage = areaEffect.AreaEffect != AreaEffectType.Disabled ? areaEffect.AreaEffectDamage * (areaEffect.AreaEffectRadius * 0.5f) : 0;
var scaledDamage = (((info.BaseDamagePool * damageScale) + areaDamage) * info.AmmoDef.Const.ShieldModifier) * info.AmmoDef.Const.ShieldBypassMod;
if (fallOff)
{
var fallOffMultipler = MathHelperD.Clamp(1.0 - ((info.DistanceTraveled - info.AmmoDef.DamageScales.FallOff.Distance) / (info.AmmoDef.Const.MaxTrajectory - info.AmmoDef.DamageScales.FallOff.Distance)), info.AmmoDef.DamageScales.FallOff.MinMultipler, 1);
scaledDamage *= fallOffMultipler;
}
var detonateDamage = detonateOnEnd ? (areaEffect.Detonation.DetonationDamage * (areaEffect.Detonation.DetonationRadius * 0.5f)) * info.AmmoDef.Const.ShieldModifier : 0;
var combinedDamage = (float)(scaledDamage + detonateDamage);
if (heal)
{
combinedDamage *= -1;
}
var hit = SApi.PointAttackShieldExt(shield, hitEnt.HitPos.Value, info.Target.FiringCube.EntityId, combinedDamage, energy, info.AmmoDef.AmmoGraphics.ShieldHitDraw);
if (hit.HasValue)
{
if (heal)
{
info.BaseDamagePool = 0;
return;
}
var objHp = hit.Value;
if (info.EwarActive)
{
info.BaseHealthPool -= 1;
}
else if (objHp > 0)
{
if (!shieldByPass)
{
info.BaseDamagePool = 0;
}
else
{
info.BaseDamagePool *= info.AmmoDef.Const.ShieldBypassMod;
}
}
else
{
info.BaseDamagePool = (objHp * -1);
}
if (info.AmmoDef.Mass <= 0)
{
return;
}
var speed = info.AmmoDef.Trajectory.DesiredSpeed > 0 ? info.AmmoDef.Trajectory.DesiredSpeed : 1;
ApplyProjectileForce((MyEntity)shield.CubeGrid, hitEnt.HitPos.Value, hitEnt.Intersection.Direction, info.AmmoDef.Mass * speed);
}
}
private static void PushPull(HitEntity hitEnt, ProInfo info)
{
var depletable = info.ConsumableDef.AreaEffect.EwarFields.Depletable;
var healthPool = depletable && info.BaseHealthPool > 0 ? info.BaseHealthPool : float.MaxValue;
if (healthPool <= 0)
{
return;
}
if (hitEnt.Entity.Physics == null || !hitEnt.Entity.Physics.Enabled || hitEnt.Entity.Physics.IsStatic || !hitEnt.HitPos.HasValue)
{
return;
}
var forceDef = info.ConsumableDef.AreaEffect.EwarFields.Force;
Vector3D forceFrom = Vector3D.Zero;
Vector3D forceTo = Vector3D.Zero;
Vector3D forcePosition = Vector3D.Zero;
if (forceDef.ForceFrom == Force.ProjectileLastPosition)
{
forceFrom = hitEnt.Intersection.From;
}
else if (forceDef.ForceFrom == Force.ProjectileOrigin)
{
forceFrom = info.Origin;
}
else if (forceDef.ForceFrom == Force.HitPosition)
{
forceFrom = hitEnt.HitPos.Value;
}
else if (forceDef.ForceFrom == Force.TargetCenter)
{
forceFrom = hitEnt.Entity.PositionComp.WorldAABB.Center;
}
else if (forceDef.ForceFrom == Force.TargetCenterOfMass)
{
forceFrom = hitEnt.Entity.Physics.CenterOfMassWorld;
}
if (forceDef.ForceTo == Force.ProjectileLastPosition)
{
forceTo = hitEnt.Intersection.From;
}
else if (forceDef.ForceTo == Force.ProjectileOrigin)
{
forceTo = info.Origin;
}
else if (forceDef.ForceTo == Force.HitPosition)
{
forceTo = hitEnt.HitPos.Value;
}
else if (forceDef.ForceTo == Force.TargetCenter)
{
forceTo = hitEnt.Entity.PositionComp.WorldAABB.Center;
}
else if (forceDef.ForceTo == Force.TargetCenterOfMass)
{
forceTo = hitEnt.Entity.Physics.CenterOfMassWorld;
}
if (forceDef.Position == Force.ProjectileLastPosition)
{
forcePosition = hitEnt.Intersection.From;
}
else if (forceDef.Position == Force.ProjectileOrigin)
{
forcePosition = info.Origin;
}
else if (forceDef.Position == Force.HitPosition)
{
forcePosition = hitEnt.HitPos.Value;
}
else if (forceDef.Position == Force.TargetCenter)
{
forcePosition = hitEnt.Entity.PositionComp.WorldAABB.Center;
}
else if (forceDef.Position == Force.TargetCenterOfMass)
{
forcePosition = hitEnt.Entity.Physics.CenterOfMassWorld;
}
var hitDir = forceTo - forceFrom;
Vector3D normHitDir;
Vector3D.Normalize(ref hitDir, out normHitDir);
normHitDir = info.ConsumableDef.Const.AreaEffect == PushField ? normHitDir : -normHitDir;
hitEnt.Entity.Physics.AddForce(MyPhysicsForceType.APPLY_WORLD_IMPULSE_AND_WORLD_ANGULAR_IMPULSE, normHitDir * (info.ConsumableDef.Const.AreaEffectDamage * hitEnt.Entity.Physics.Mass), forcePosition, Vector3.Zero);
if (depletable)
{
info.BaseHealthPool -= healthPool;
}
}
private static void DamageProjectile(HitEntity hitEnt, ProInfo attacker)
{
var pTarget = hitEnt.Projectile;
if (pTarget == null)
{
return;
}
attacker.ObjectsHit++;
var objHp = pTarget.Info.BaseHealthPool;
var integrityCheck = attacker.AmmoDef.DamageScales.MaxIntegrity > 0;
if (integrityCheck && objHp > attacker.AmmoDef.DamageScales.MaxIntegrity)
{
return;
}
float damageScale = 1;
if (attacker.AmmoDef.Const.VirtualBeams)
{
damageScale *= attacker.WeaponCache.Hits;
}
var scaledDamage = attacker.BaseDamagePool * damageScale;
var fallOff = attacker.AmmoDef.Const.FallOffScaling && attacker.DistanceTraveled > attacker.AmmoDef.DamageScales.FallOff.Distance;
if (fallOff)
{
var fallOffMultipler = (float)MathHelperD.Clamp(1.0 - ((attacker.DistanceTraveled - attacker.AmmoDef.DamageScales.FallOff.Distance) / (attacker.AmmoDef.Const.MaxTrajectory - attacker.AmmoDef.DamageScales.FallOff.Distance)), attacker.AmmoDef.DamageScales.FallOff.MinMultipler, 1);
scaledDamage *= fallOffMultipler;
}
if (scaledDamage >= objHp)
{
attacker.BaseDamagePool -= objHp;
pTarget.Info.BaseHealthPool = 0;
pTarget.State = Projectile.ProjectileState.Destroy;
}
else
{
attacker.BaseDamagePool = 0;
pTarget.Info.BaseHealthPool -= scaledDamage;
if (attacker.DetonationDamage > 0 && attacker.AmmoDef.AreaEffect.Detonation.DetonateOnEnd)
{
var areaSphere = new BoundingSphereD(pTarget.Position, attacker.AmmoDef.AreaEffect.Detonation.DetonationRadius);
foreach (var sTarget in attacker.Ai.LiveProjectile)
{
if (areaSphere.Contains(sTarget.Position) != ContainmentType.Disjoint)
{
if (attacker.DetonationDamage >= sTarget.Info.BaseHealthPool)
{
sTarget.Info.BaseHealthPool = 0;
sTarget.State = Projectile.ProjectileState.Destroy;
}
else
{
sTarget.Info.BaseHealthPool -= attacker.DetonationDamage;
}
}
}
}
}
}
private void DamageVoxel(HitEntity hitEnt, ProInfo info)
{
var entity = hitEnt.Entity;
var destObj = hitEnt.Entity as MyVoxelBase;
if (destObj == null || entity == null || !hitEnt.HitPos.HasValue)
{
return;
}
var shieldHeal = info.AmmoDef.DamageScales.Shields.Type == ShieldDef.ShieldType.Heal;
if (!info.AmmoDef.Const.VoxelDamage || shieldHeal)
{
info.BaseDamagePool = 0;
return;
}
using (destObj.Pin())
{
var detonateOnEnd = info.AmmoDef.Const.AmmoAreaEffect && info.AmmoDef.AreaEffect.Detonation.DetonateOnEnd && info.AmmoDef.AreaEffect.AreaEffect != AreaEffectType.Radiant;
info.ObjectsHit++;
float damageScale = 1;
if (info.AmmoDef.Const.VirtualBeams)
{
damageScale *= info.WeaponCache.Hits;
}
var scaledDamage = info.BaseDamagePool * damageScale;
var fallOff = info.AmmoDef.Const.FallOffScaling && info.DistanceTraveled > info.AmmoDef.DamageScales.FallOff.Distance;
if (fallOff)
{
var fallOffMultipler = (float)MathHelperD.Clamp(1.0 - ((info.DistanceTraveled - info.AmmoDef.DamageScales.FallOff.Distance) / (info.AmmoDef.Const.MaxTrajectory - info.AmmoDef.DamageScales.FallOff.Distance)), info.AmmoDef.DamageScales.FallOff.MinMultipler, 1);
scaledDamage *= fallOffMultipler;
}
var oRadius = info.AmmoDef.AreaEffect.AreaEffectRadius;
var minTestRadius = info.DistanceTraveled - info.PrevDistanceTraveled;
var tRadius = oRadius < minTestRadius ? minTestRadius : oRadius;
var objHp = (int)MathHelper.Clamp(MathFuncs.VolumeCube(MathFuncs.LargestCubeInSphere(tRadius)), 1, double.MaxValue);
var sync = MpActive && IsServer;
if (tRadius > 5)
{
objHp *= 5;
}
if (scaledDamage < objHp)
{
var reduceBy = objHp / scaledDamage;
oRadius /= reduceBy;
if (oRadius < 1)
{
oRadius = 1;
}
info.BaseDamagePool = 0;
}
else
{
info.BaseDamagePool -= objHp;
if (oRadius < minTestRadius)
{
oRadius = minTestRadius;
}
}
destObj.PerformCutOutSphereFast(hitEnt.HitPos.Value, (float)oRadius, true);
if (detonateOnEnd)
{
var det = info.AmmoDef.AreaEffect.Detonation;
var dRadius = det.DetonationRadius;
var dObjHp = (int)MathHelper.Clamp(MathFuncs.VolumeCube(MathFuncs.LargestCubeInSphere(dRadius)), 1, double.MaxValue);
if (dRadius > 5)
{
dObjHp *= 5;
}
dObjHp *= 5;
var dDamage = det.DetonationDamage;
var reduceBy = dObjHp / dDamage;
dRadius /= reduceBy;
if (dRadius < 1.5)
{
dRadius = 1.5f;
}
if (sync)
{
destObj.PerformCutOutSphereFast(hitEnt.HitPos.Value, dRadius, true);
}
}
}
}
private void DamageDestObj(HitEntity hitEnt, ProInfo info)
{
var entity = hitEnt.Entity;
var destObj = hitEnt.Entity as IMyDestroyableObject;
if (destObj == null || entity == null)
{
return;
}
var shieldHeal = info.AmmoDef.DamageScales.Shields.Type == ShieldDef.ShieldType.Heal;
var shieldByPass = info.AmmoDef.DamageScales.Shields.Type == ShieldDef.ShieldType.Bypass;
var sync = MpActive && IsServer;
var attackerId = info.Target.FiringCube.EntityId;
var objHp = destObj.Integrity;
var integrityCheck = info.AmmoDef.DamageScales.MaxIntegrity > 0;
if (integrityCheck && objHp > info.AmmoDef.DamageScales.MaxIntegrity || shieldHeal)
{
info.BaseDamagePool = 0;
return;
}
var character = hitEnt.Entity as IMyCharacter;
float damageScale = 1;
if (info.AmmoDef.Const.VirtualBeams)
{
damageScale *= info.WeaponCache.Hits;
}
if (character != null && info.AmmoDef.DamageScales.Characters >= 0)
{
damageScale *= info.AmmoDef.DamageScales.Characters;
}
var scaledDamage = info.BaseDamagePool * damageScale;
var fallOff = info.AmmoDef.Const.FallOffScaling && info.DistanceTraveled > info.AmmoDef.DamageScales.FallOff.Distance;
if (fallOff)
{
var fallOffMultipler = (float)MathHelperD.Clamp(1.0 - ((info.DistanceTraveled - info.AmmoDef.DamageScales.FallOff.Distance) / (info.AmmoDef.Const.MaxTrajectory - info.AmmoDef.DamageScales.FallOff.Distance)), info.AmmoDef.DamageScales.FallOff.MinMultipler, 1);
scaledDamage *= fallOffMultipler;
}
if (scaledDamage < objHp)
{
info.BaseDamagePool = 0;
}
else
{
info.BaseDamagePool -= objHp;
}
if (!IsClient)
{
destObj.DoDamage(scaledDamage, !shieldByPass ? MyDamageType.Bullet : MyDamageType.Drill, sync, null, attackerId);
}
if (info.AmmoDef.Mass > 0)
{
var speed = info.AmmoDef.Trajectory.DesiredSpeed > 0 ? info.AmmoDef.Trajectory.DesiredSpeed : 1;
ApplyProjectileForce(entity, entity.PositionComp.WorldAABB.Center, hitEnt.Intersection.Direction, (info.AmmoDef.Mass * speed));
}
}
private void DamageGrid(HitEntity hitEnt, ProInfo t)
{
var grid = hitEnt.Entity as MyCubeGrid;
if (grid == null || grid.MarkedForClose || !hitEnt.HitPos.HasValue || hitEnt.Blocks == null)
{
hitEnt.Blocks?.Clear();
return;
}
if (t.AmmoDef.DamageScales.Shields.Type == ShieldDef.ShieldType.Heal || (!t.AmmoDef.Const.SelfDamage || !MyAPIGateway.Session.SessionSettings.EnableTurretsFriendlyFire) && t.Ai.MyGrid.IsSameConstructAs(grid))
{
t.BaseDamagePool = 0;
return;
}
_destroyedSlims.Clear();
_destroyedSlimsClient.Clear();
var largeGrid = grid.GridSizeEnum == MyCubeSize.Large;
var areaRadius = largeGrid ? t.AmmoDef.Const.AreaRadiusLarge : t.AmmoDef.Const.AreaRadiusSmall;
var detonateRadius = largeGrid ? t.AmmoDef.Const.DetonateRadiusLarge : t.AmmoDef.Const.DetonateRadiusSmall;
var maxObjects = t.AmmoDef.Const.MaxObjectsHit;
var areaEffect = t.AmmoDef.AreaEffect.AreaEffect;
var explosive = areaEffect == AreaEffectType.Explosive;
var radiant = areaEffect == AreaEffectType.Radiant;
var detonateOnEnd = t.AmmoDef.AreaEffect.Detonation.DetonateOnEnd;
var detonateDmg = t.DetonationDamage;
var shieldBypass = t.AmmoDef.DamageScales.Shields.Type == ShieldDef.ShieldType.Bypass;
var attackerId = shieldBypass ? grid.EntityId : t.Target.FiringCube.EntityId;
var attacker = shieldBypass ? (MyEntity)grid : t.Target.FiringCube;
var areaEffectDmg = areaEffect != AreaEffectType.Disabled ? t.AreaEffectDamage : 0;
var hitMass = t.AmmoDef.Mass;
var sync = MpActive && (DedicatedServer || IsServer);
var hasAreaDmg = areaEffectDmg > 0;
var radiantCascade = radiant && !detonateOnEnd;
var primeDamage = !radiantCascade || !hasAreaDmg;
var radiantBomb = radiant && detonateOnEnd;
var damageType = explosive || radiant ? MyDamageType.Explosion : MyDamageType.Bullet;
var fallOff = t.AmmoDef.Const.FallOffScaling && t.DistanceTraveled > t.AmmoDef.DamageScales.FallOff.Distance;
var fallOffMultipler = 1f;
if (fallOff)
{
fallOffMultipler = (float)MathHelperD.Clamp(1.0 - ((t.DistanceTraveled - t.AmmoDef.DamageScales.FallOff.Distance) / (t.AmmoDef.Const.MaxTrajectory - t.AmmoDef.DamageScales.FallOff.Distance)), t.AmmoDef.DamageScales.FallOff.MinMultipler, 1);
}
var damagePool = t.BaseDamagePool;
if (t.AmmoDef.Const.VirtualBeams)
{
var hits = t.WeaponCache.Hits;
damagePool *= hits;
areaEffectDmg *= hits;
}
var objectsHit = t.ObjectsHit;
var countBlocksAsObjects = t.AmmoDef.ObjectsHit.CountBlocks;
List <Vector3I> radiatedBlocks = null;
if (radiant)
{
GetBlockSphereDb(grid, areaRadius, out radiatedBlocks);
}
var done = false;
var nova = false;
var outOfPew = false;
for (int i = 0; i < hitEnt.Blocks.Count; i++)
{
if (done || outOfPew && !nova)
{
break;
}
var rootBlock = hitEnt.Blocks[i];
if (!nova)
{
if (_destroyedSlims.Contains(rootBlock) || _destroyedSlimsClient.Contains(rootBlock))
{
continue;
}
if (rootBlock.IsDestroyed)
{
_destroyedSlims.Add(rootBlock);
if (IsClient)
{
_destroyedSlimsClient.Add(rootBlock);
if (_slimHealthClient.ContainsKey(rootBlock))
{
_slimHealthClient.Remove(rootBlock);
}
}
continue;
}
}
var door = rootBlock.FatBlock as MyDoorBase;
if (door != null && door.Open && !HitDoor(hitEnt, door))
{
continue;
}
var radiate = radiantCascade || nova;
var dmgCount = 1;
if (radiate)
{
if (nova)
{
GetBlockSphereDb(grid, detonateRadius, out radiatedBlocks);
}
if (radiatedBlocks != null)
{
ShiftAndPruneBlockSphere(grid, rootBlock.Position, radiatedBlocks, _slimsSortedList);
}
done = nova;
dmgCount = _slimsSortedList.Count;
}
for (int j = 0; j < dmgCount; j++)
{
var block = radiate ? _slimsSortedList[j].Slim : rootBlock;
var blockHp = !IsClient ? block.Integrity : _slimHealthClient.ContainsKey(block) ? _slimHealthClient[block] : block.Integrity;
float damageScale = 1;
if (t.AmmoDef.Const.DamageScaling)
{
var d = t.AmmoDef.DamageScales;
if (d.MaxIntegrity > 0 && blockHp > d.MaxIntegrity)
{
outOfPew = true;
damagePool = 0;
continue;
}
if (d.Grids.Large >= 0 && largeGrid)
{
damageScale *= d.Grids.Large;
}
else if (d.Grids.Small >= 0 && !largeGrid)
{
damageScale *= d.Grids.Small;
}
MyDefinitionBase blockDef = null;
if (t.AmmoDef.Const.ArmorScaling)
{
blockDef = block.BlockDefinition;
var isArmor = AllArmorBaseDefinitions.Contains(blockDef);
if (isArmor && d.Armor.Armor >= 0)
{
damageScale *= d.Armor.Armor;
}
else if (!isArmor && d.Armor.NonArmor >= 0)
{
damageScale *= d.Armor.NonArmor;
}
if (isArmor && (d.Armor.Light >= 0 || d.Armor.Heavy >= 0))
{
var isHeavy = HeavyArmorBaseDefinitions.Contains(blockDef);
if (isHeavy && d.Armor.Heavy >= 0)
{
damageScale *= d.Armor.Heavy;
}
else if (!isHeavy && d.Armor.Light >= 0)
{
damageScale *= d.Armor.Light;
}
}
}
if (t.AmmoDef.Const.CustomDamageScales)
{
if (blockDef == null)
{
blockDef = block.BlockDefinition;
}
float modifier;
var found = t.AmmoDef.Const.CustomBlockDefinitionBasesToScales.TryGetValue(blockDef, out modifier);
if (found)
{
damageScale *= modifier;
}
else if (t.AmmoDef.DamageScales.Custom.IgnoreAllOthers)
{
continue;
}
}
if (fallOff)
{
damageScale *= fallOffMultipler;
}
}
var blockIsRoot = block == rootBlock;
var primaryDamage = primeDamage || blockIsRoot;
if (damagePool <= 0 && primaryDamage || objectsHit >= maxObjects)
{
break;
}
var scaledDamage = damagePool * damageScale;
if (primaryDamage)
{
if (countBlocksAsObjects)
{
objectsHit++;
}
if (scaledDamage <= blockHp)
{
outOfPew = true;
damagePool = 0;
}
else
{
_destroyedSlims.Add(block);
if (IsClient)
{
_destroyedSlimsClient.Add(block);
if (_slimHealthClient.ContainsKey(block))
{
_slimHealthClient.Remove(block);
}
}
damagePool -= blockHp;
}
}
else
{
scaledDamage = areaEffectDmg * damageScale;
if (scaledDamage >= blockHp)
{
_destroyedSlims.Add(block);
if (IsClient)
{
_destroyedSlimsClient.Add(block);
if (_slimHealthClient.ContainsKey(block))
{
_slimHealthClient.Remove(block);
}
}
}
}
if (!IsClient)
{
block.DoDamage(scaledDamage, damageType, sync, null, attackerId);
}
else
{
var hasBlock = _slimHealthClient.ContainsKey(block);
if (hasBlock && _slimHealthClient[block] - scaledDamage > 0)
{
_slimHealthClient[block] -= scaledDamage;
}
else if (hasBlock)
{
_slimHealthClient.Remove(block);
}
else if (block.Integrity - scaledDamage > 0)
{
_slimHealthClient[block] = blockHp - scaledDamage;
}
}
var theEnd = damagePool <= 0 || objectsHit >= maxObjects;
if (explosive && (!detonateOnEnd && blockIsRoot || detonateOnEnd && theEnd))
{
var rootPos = grid.GridIntegerToWorld(rootBlock.Position);
if (areaEffectDmg > 0)
{
SUtils.CreateMissileExplosion(this, areaEffectDmg * damageScale, areaRadius, rootPos, hitEnt.Intersection.Direction, attacker, grid, t.AmmoDef, true);
}
if (detonateOnEnd && theEnd)
{
SUtils.CreateMissileExplosion(this, detonateDmg * damageScale, detonateRadius, rootPos, hitEnt.Intersection.Direction, attacker, grid, t.AmmoDef, true);
}
}
else if (!nova)
{
if (hitMass > 0 && blockIsRoot)
{
var speed = t.AmmoDef.Trajectory.DesiredSpeed > 0 ? t.AmmoDef.Trajectory.DesiredSpeed : 1;
ApplyProjectileForce(grid, grid.GridIntegerToWorld(rootBlock.Position), hitEnt.Intersection.Direction, (hitMass * speed));
}
if (radiantBomb && theEnd)
{
nova = true;
i--;
t.BaseDamagePool = 0;
t.ObjectsHit = maxObjects;
objectsHit = int.MinValue;
var aInfo = t.AmmoDef.AreaEffect;
var dInfo = aInfo.Detonation;
if (dInfo.DetonationDamage > 0)
{
damagePool = detonateDmg;
}
else if (aInfo.AreaEffectDamage > 0)
{
damagePool = areaEffectDmg;
}
else
{
damagePool = scaledDamage;
}
break;
}
}
}
}
if (!countBlocksAsObjects)
{
t.ObjectsHit += 1;
}
if (!nova)
{
t.BaseDamagePool = damagePool;
t.ObjectsHit = objectsHit;
}
if (radiantCascade || nova)
{
_slimsSortedList.Clear();
}
hitEnt.Blocks.Clear();
}
internal int GetEntityCompareDist(HitEntity x, HitEntity y, ProInfo info)
{
var xDist = double.MaxValue;
var yDist = double.MaxValue;
var beam = x.Intersection;
var count = y != null ? 2 : 1;
var eWarPulse = info.AmmoDef.Const.Ewar && info.AmmoDef.Const.Pulse;
var triggerEvent = eWarPulse && !info.EwarAreaPulse && info.AmmoDef.Const.EwarTriggerRange > 0;
for (int i = 0; i < count; i++)
{
var isX = i == 0;
MyEntity ent;
HitEntity hitEnt;
HitEntity otherHit;
if (isX)
{
hitEnt = x;
otherHit = y;
ent = hitEnt.Entity;
}
else
{
hitEnt = y;
otherHit = x;
ent = hitEnt.Entity;
}
var dist = double.MaxValue;
var shield = ent as IMyTerminalBlock;
var grid = ent as MyCubeGrid;
var voxel = ent as MyVoxelBase;
if (triggerEvent && (info.Ai.Targets.ContainsKey(ent) || shield != null))
{
hitEnt.PulseTrigger = true;
}
else if (hitEnt.Projectile != null)
{
dist = hitEnt.HitDist.Value;
}
else if (shield != null)
{
hitEnt.Hit = true;
dist = hitEnt.HitDist.Value;
}
else if (grid != null)
{
/*
* var otherGrid = otherHit?.Entity as MyCubeGrid;
* if (otherGrid != null && otherGrid.IsInSameLogicalGroupAs(grid))
* hitEnt.SubGrids.Add(otherHit);
*/
if (hitEnt.Hit)
{
dist = Vector3D.Distance(hitEnt.Intersection.From, hitEnt.HitPos.Value);
hitEnt.HitDist = dist;
}
else if (hitEnt.HitPos != null)
{
dist = Vector3D.Distance(hitEnt.Intersection.From, hitEnt.HitPos.Value);
hitEnt.HitDist = dist;
hitEnt.Hit = true;
}
else
{
if (hitEnt.SphereCheck || info.EwarActive && eWarPulse)
{
var ewarActive = hitEnt.EventType == Field || hitEnt.EventType == Effect;
var hitPos = !ewarActive ? hitEnt.PruneSphere.Center + (hitEnt.Intersection.Direction * hitEnt.PruneSphere.Radius) : hitEnt.PruneSphere.Center;
if (hitEnt.SelfHit && Vector3D.DistanceSquared(hitPos, hitEnt.Info.Origin) <= grid.GridSize * grid.GridSize)
{
continue;
}
if (!ewarActive)
{
GetAndSortBlocksInSphere(hitEnt.Info.AmmoDef, hitEnt.Info.System, grid, hitEnt.PruneSphere, false, hitEnt.Blocks);
}
if (hitEnt.Blocks.Count > 0 || ewarActive)
{
dist = 0;
hitEnt.HitDist = dist;
hitEnt.Hit = true;
hitEnt.HitPos = hitPos;
}
}
else
{
var closestBlockFound = false;
for (int j = 0; j < hitEnt.Vector3ICache.Count; j++)
{
var firstBlock = grid.GetCubeBlock(hitEnt.Vector3ICache[j]) as IMySlimBlock;
MatrixD transform = grid.WorldMatrix;
if (firstBlock != null && !firstBlock.IsDestroyed && firstBlock != hitEnt.Info.Target.FiringCube.SlimBlock)
{
hitEnt.Blocks.Add(firstBlock);
if (closestBlockFound)
{
continue;
}
MyOrientedBoundingBoxD obb;
var fat = firstBlock.FatBlock;
if (fat != null)
{
obb = new MyOrientedBoundingBoxD(fat.Model.BoundingBox, fat.PositionComp.WorldMatrixRef);
}
else
{
Vector3 halfExt;
firstBlock.ComputeScaledHalfExtents(out halfExt);
var blockBox = new BoundingBoxD(-halfExt, halfExt);
transform.Translation = grid.GridIntegerToWorld(firstBlock.Position);
obb = new MyOrientedBoundingBoxD(blockBox, transform);
}
var hitDist = obb.Intersects(ref beam) ?? Vector3D.Distance(beam.From, obb.Center);
var hitPos = beam.From + (beam.Direction * hitDist);
if (hitEnt.SelfHit)
{
if (Vector3D.DistanceSquared(hitPos, hitEnt.Info.Origin) <= grid.GridSize * 3)
{
hitEnt.Blocks.Clear();
}
else
{
dist = hitDist;
hitEnt.HitDist = dist;
hitEnt.Hit = true;
hitEnt.HitPos = hitPos;
}
break;
}
dist = hitDist;
hitEnt.HitDist = dist;
hitEnt.Hit = true;
hitEnt.HitPos = hitPos;
closestBlockFound = true;
}
}
}
}
}
else if (voxel != null)
{
hitEnt.Hit = true;
dist = hitEnt.HitDist.Value;
hitEnt.HitDist = dist;
}
else if (ent is IMyDestroyableObject)
{
if (hitEnt.Hit)
{
dist = Vector3D.Distance(hitEnt.Intersection.From, hitEnt.HitPos.Value);
}
else
{
if (hitEnt.SphereCheck || info.EwarActive && eWarPulse)
{
var ewarActive = hitEnt.EventType == Field || hitEnt.EventType == Effect;
dist = 0;
hitEnt.HitDist = dist;
hitEnt.Hit = true;
var hitPos = !ewarActive ? hitEnt.PruneSphere.Center + (hitEnt.Intersection.Direction * hitEnt.PruneSphere.Radius) : hitEnt.PruneSphere.Center;
hitEnt.HitPos = hitPos;
}
else
{
var transform = ent.PositionComp.WorldMatrixRef;
var box = ent.PositionComp.LocalAABB;
var obb = new MyOrientedBoundingBoxD(box, transform);
dist = obb.Intersects(ref beam) ?? double.MaxValue;
if (dist < double.MaxValue)
{
hitEnt.Hit = true;
hitEnt.HitPos = beam.From + (beam.Direction * dist);
hitEnt.HitDist = dist;
}
}
}
}
if (isX)
{
xDist = dist;
}
else
{
yDist = dist;
}
}
return(xDist.CompareTo(yDist));
}
/// <summary>
///
/// </summary>
/// <param name="ProjeIn"></param>
public void UpdataLevelOfLine(ProInfo projeIn)
{
LevelOfLine = ElecCalsToolBox.GetLevelOfLine(projeIn.Volt, projeIn.ACorDC);
}
private void DamageVoxel(HitEntity hitEnt, ProInfo info, bool canDamage)
{
var entity = hitEnt.Entity;
var destObj = hitEnt.Entity as MyVoxelBase;
if (destObj == null || entity == null || !hitEnt.HitPos.HasValue)
{
return;
}
var shieldHeal = info.AmmoDef.DamageScales.Shields.Type == ShieldDef.ShieldType.Heal;
if (!info.AmmoDef.Const.VoxelDamage || shieldHeal)
{
info.BaseDamagePool = 0;
return;
}
using (destObj.Pin())
{
var detonateOnEnd = info.AmmoDef.Const.AmmoAreaEffect && info.AmmoDef.AreaEffect.Detonation.DetonateOnEnd && info.AmmoDef.AreaEffect.AreaEffect != AreaEffectType.Radiant;
info.ObjectsHit++;
float damageScale = 1;
if (info.AmmoDef.Const.VirtualBeams)
{
damageScale *= info.WeaponCache.Hits;
}
var scaledDamage = info.BaseDamagePool * damageScale;
var fallOff = info.AmmoDef.Const.FallOffScaling && info.DistanceTraveled > info.AmmoDef.DamageScales.FallOff.Distance;
if (fallOff)
{
var fallOffMultipler = (float)MathHelperD.Clamp(1.0 - ((info.DistanceTraveled - info.AmmoDef.DamageScales.FallOff.Distance) / (info.AmmoDef.Const.MaxTrajectory - info.AmmoDef.DamageScales.FallOff.Distance)), info.AmmoDef.DamageScales.FallOff.MinMultipler, 1);
scaledDamage *= fallOffMultipler;
}
var oRadius = info.AmmoDef.AreaEffect.AreaEffectRadius;
var minTestRadius = info.DistanceTraveled - info.PrevDistanceTraveled;
var tRadius = oRadius < minTestRadius ? minTestRadius : oRadius;
var objHp = (int)MathHelper.Clamp(MathFuncs.VolumeCube(MathFuncs.LargestCubeInSphere(tRadius)), 5000, double.MaxValue);
if (tRadius > 5)
{
objHp *= 5;
}
if (scaledDamage < objHp)
{
var reduceBy = objHp / scaledDamage;
oRadius /= reduceBy;
if (oRadius < 1)
{
oRadius = 1;
}
info.BaseDamagePool = 0;
}
else
{
info.BaseDamagePool -= objHp;
if (oRadius < minTestRadius)
{
oRadius = minTestRadius;
}
}
destObj.PerformCutOutSphereFast(hitEnt.HitPos.Value, (float)oRadius, true);
//Log.Line($"TestHealth: {objHp} - tRadius:{tRadius} - oRadius:{oRadius} - travel:{minTestRadius} - base:{info.BaseDamagePool} - det:{detonateOnEnd}");
if (detonateOnEnd && info.BaseDamagePool <= 0)
{
var det = info.AmmoDef.AreaEffect.Detonation;
var dRadius = det.DetonationRadius;
var dDamage = det.DetonationDamage;
//var dObjHp = (int)MathHelper.Clamp(MathFuncs.VolumeCube(MathFuncs.LargestCubeInSphere(dRadius)), 5000, double.MaxValue);
//if (dRadius > 5) dObjHp *= 5;
//dObjHp *= 5;
//var reduceBy = dObjHp / dDamage;
//dRadius /= reduceBy;
if (dRadius < 1.5)
{
dRadius = 1.5f;
}
//Log.Line($"radius: {det.DetonationRadius} - dRadius:{dRadius} - reduceBy:{reduceBy} - dObjHp:{dObjHp}");
if (canDamage)
{
//destObj.PerformCutOutSphereFast(hitEnt.HitPos.Value, dRadius, true);
SUtils.CreateMissileExplosion(this, dDamage, dRadius, hitEnt.HitPos.Value, hitEnt.Intersection.Direction, info.Target.FiringCube, destObj, info.AmmoDef, true);
}
}
}
}
