public static bool Prefix(AttackDirector.AttackSequence __instance, Weapon weapon, int groupIdx, int weaponIdx, int numberOfShots, bool indirectFire, float dodgedDamage, ref WeaponHitInfo __result)
{
WeaponHitInfo hitInfo = new WeaponHitInfo();
hitInfo.attackerId = __instance.attacker.GUID;
hitInfo.targetId = __instance.target.GUID;
hitInfo.numberOfShots = numberOfShots;
hitInfo.stackItemUID = __instance.stackItemUID;
hitInfo.attackSequenceId = __instance.id;
hitInfo.attackGroupIndex = groupIdx;
hitInfo.attackWeaponIndex = weaponIdx;
hitInfo.toHitRolls = new float[numberOfShots];
hitInfo.locationRolls = new float[numberOfShots];
hitInfo.dodgeRolls = new float[numberOfShots];
hitInfo.dodgeSuccesses = new bool[numberOfShots];
hitInfo.hitLocations = new int[numberOfShots];
hitInfo.hitPositions = new Vector3[numberOfShots];
hitInfo.hitVariance = new int[numberOfShots];
hitInfo.hitQualities = new AttackImpactQuality[numberOfShots];
if (AttackDirector.hitLogger.IsLogEnabled)
{
Vector3 collisionWorldPos;
LineOfFireLevel lineOfFire = __instance.Director.Combat.LOS.GetLineOfFire(__instance.attacker, __instance.attackPosition, __instance.target, __instance.target.CurrentPosition, __instance.target.CurrentRotation, out collisionWorldPos);
float allModifiers = __instance.Director.Combat.ToHit.GetAllModifiers(__instance.attacker, weapon, __instance.target, __instance.attackPosition + __instance.attacker.HighestLOSPosition, __instance.target.TargetPosition, lineOfFire, __instance.isMoraleAttack);
string modifiersDescription = __instance.Director.Combat.ToHit.GetAllModifiersDescription(__instance.attacker, weapon, __instance.target, __instance.attackPosition + __instance.attacker.HighestLOSPosition, __instance.target.TargetPosition, lineOfFire, __instance.isMoraleAttack);
Pilot pilot = __instance.attacker.GetPilot();
AttackDirector.hitLogger.Log((object)string.Format("======================================== Unit Firing: {0} | Weapon: {1} | Shots: {2}", (object)__instance.attacker.DisplayName, (object)weapon.Name, (object)numberOfShots));
AttackDirector.hitLogger.Log((object)string.Format("======================================== Hit Info: GROUP {0} | ID {1}", (object)groupIdx, (object)weaponIdx));
AttackDirector.hitLogger.Log((object)string.Format("======================================== MODIFIERS: {0}... FINAL: [[ {1} ]] ", (object)modifiersDescription, (object)allModifiers));
if (pilot != null)
{
AttackDirector.hitLogger.Log((object)__instance.Director.Combat.ToHit.GetBaseToHitChanceDesc(__instance.attacker));
}
else
{
AttackDirector.hitLogger.Log((object)string.Format("======================================== Gunnery Check: NO PILOT"));
}
}
float toHitChance = __instance.Director.Combat.ToHit.GetToHitChance(__instance.attacker, weapon, __instance.target, __instance.attackPosition, __instance.target.CurrentPosition, __instance.numTargets, __instance.meleeAttackType, __instance.isMoraleAttack);
if (Mech.TEST_KNOCKDOWN)
{
toHitChance = 1f;
}
if (AttackDirector.hitLogger.IsLogEnabled)
{
AttackDirector.hitLogger.Log((object)string.Format("======================================== HIT CHANCE: [[ {0:P2} ]]", (object)toHitChance));
}
hitInfo.attackDirection = __instance.Director.Combat.HitLocation.GetAttackDirection(__instance.attackPosition, __instance.target);
hitInfo.attackDirectionVector = __instance.Director.Combat.HitLocation.GetAttackDirectionVector(__instance.attackPosition, __instance.target);
object[] args = new object[6];
HitGeneratorType hitGenType = HitGeneratorType.NotSet;
if (weapon.weaponDef.ComponentTags.Contains("wr-clustered_shots"))
{
hitGenType = HitGeneratorType.Individual;
}
if (hitGenType == HitGeneratorType.NotSet)
{
if (CustomAmmoCategories.checkExistance(weapon.StatCollection, CustomAmmoCategories.AmmoIdStatName) == true)
{
string ammoId = weapon.StatCollection.GetStatistic(CustomAmmoCategories.AmmoIdStatName).Value <string>();
ExtAmmunitionDef extAmmo = CustomAmmoCategories.findExtAmmo(ammoId);
hitGenType = extAmmo.HitGenerator;
}
if (hitGenType == HitGeneratorType.NotSet)
{
ExtWeaponDef extWeapon = CustomAmmoCategories.getExtWeaponDef(weapon.weaponDef.Description.Id);
hitGenType = extWeapon.HitGenerator;
}
}
if (hitGenType != HitGeneratorType.NotSet)
{
switch (hitGenType)
{
case HitGeneratorType.Individual:
args[0] = hitInfo; args[1] = groupIdx; args[2] = weaponIdx; args[3] = weapon; args[4] = toHitChance; args[5] = dodgedDamage;
typeof(AttackDirector.AttackSequence).GetMethod("GetIndividualHits", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(__instance, args);
hitInfo = (WeaponHitInfo)args[0];
break;
case HitGeneratorType.Cluster:
args[0] = hitInfo; args[1] = groupIdx; args[2] = weaponIdx; args[3] = weapon; args[4] = toHitChance; args[5] = dodgedDamage;
typeof(AttackDirector.AttackSequence).GetMethod("GetClusteredHits", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(__instance, args);
hitInfo = (WeaponHitInfo)args[0];
//__instance.GetClusteredHits(ref hitInfo, groupIdx, weaponIdx, weapon, toHitChance, dodgedDamage);
break;
case HitGeneratorType.Streak:
//args[0] = hitInfo; args[1] = groupIdx; args[2] = weaponIdx; args[3] = weapon; args[4] = toHitChance; args[5] = dodgedDamage;
//typeof(AttackDirector.AttackSequence).GetMethod("GetClusteredHits", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(__instance, args);
//hitInfo = (WeaponHitInfo)args[0];
AttackSequence_GenerateHitInfo.GetStreakHits(__instance, ref hitInfo, groupIdx, weaponIdx, weapon, toHitChance, dodgedDamage);
//__instance.GetClusteredHits(ref hitInfo, groupIdx, weaponIdx, weapon, toHitChance, dodgedDamage);
break;
default:
AttackDirector.attackLogger.LogError((object)string.Format("GenerateHitInfo found invalid weapon type: {0}, using basic hit info", (object)hitGenType));
args[0] = hitInfo; args[1] = groupIdx; args[2] = weaponIdx; args[3] = weapon; args[4] = toHitChance; args[5] = dodgedDamage;
typeof(AttackDirector.AttackSequence).GetMethod("GetIndividualHits", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(__instance, args);
hitInfo = (WeaponHitInfo)args[0];
//__instance.GetIndividualHits(ref hitInfo, groupIdx, weaponIdx, weapon, toHitChance, dodgedDamage);
break;
}
}
else
{
switch (weapon.Type)
{
case WeaponType.Autocannon:
case WeaponType.Gauss:
case WeaponType.Laser:
case WeaponType.PPC:
case WeaponType.Flamer:
case WeaponType.Melee:
args[0] = hitInfo; args[1] = groupIdx; args[2] = weaponIdx; args[3] = weapon; args[4] = toHitChance; args[5] = dodgedDamage;
typeof(AttackDirector.AttackSequence).GetMethod("GetIndividualHits", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(__instance, args);
hitInfo = (WeaponHitInfo)args[0];
//__instance.GetIndividualHits(ref hitInfo, groupIdx, weaponIdx, weapon, toHitChance, dodgedDamage);
break;
case WeaponType.LRM:
args[0] = hitInfo; args[1] = groupIdx; args[2] = weaponIdx; args[3] = weapon; args[4] = toHitChance; args[5] = dodgedDamage;
typeof(AttackDirector.AttackSequence).GetMethod("GetClusteredHits", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(__instance, args);
hitInfo = (WeaponHitInfo)args[0];
//__instance.GetClusteredHits(ref hitInfo, groupIdx, weaponIdx, weapon, toHitChance, dodgedDamage);
break;
case WeaponType.SRM:
args[0] = hitInfo; args[1] = groupIdx; args[2] = weaponIdx; args[3] = weapon; args[4] = toHitChance; args[5] = dodgedDamage;
typeof(AttackDirector.AttackSequence).GetMethod("GetIndividualHits", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(__instance, args);
hitInfo = (WeaponHitInfo)args[0];
//__instance.GetIndividualHits(ref hitInfo, groupIdx, weaponIdx, weapon, toHitChance, dodgedDamage);
break;
case WeaponType.MachineGun:
args[0] = hitInfo; args[1] = groupIdx; args[2] = weaponIdx; args[3] = weapon; args[4] = toHitChance; args[5] = dodgedDamage;
typeof(AttackDirector.AttackSequence).GetMethod("GetIndividualHits", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(__instance, args);
hitInfo = (WeaponHitInfo)args[0];
//__instance.GetIndividualHits(ref hitInfo, groupIdx, weaponIdx, weapon, toHitChance, dodgedDamage);
break;
default:
AttackDirector.attackLogger.LogError((object)string.Format("GenerateHitInfo found invalid weapon type: {0}, using basic hit info", (object)weapon.Type));
args[0] = hitInfo; args[1] = groupIdx; args[2] = weaponIdx; args[3] = weapon; args[4] = toHitChance; args[5] = dodgedDamage;
typeof(AttackDirector.AttackSequence).GetMethod("GetIndividualHits", BindingFlags.Instance | BindingFlags.NonPublic).Invoke(__instance, args);
hitInfo = (WeaponHitInfo)args[0];
//__instance.GetIndividualHits(ref hitInfo, groupIdx, weaponIdx, weapon, toHitChance, dodgedDamage);
break;
}
}
__result = hitInfo;
return(false);
//return hitInfo;
}
public static bool Prefix(AmmunitionDef __instance, ref string json)
{
CustomAmmoCategoriesLog.Log.LogWrite("AmmunitionDef fromJSON ");
JObject defTemp = JObject.Parse(json);
CustomAmmoCategoriesLog.Log.LogWrite(defTemp["Description"]["Id"] + "\n");
CustomAmmoCategory custCat = CustomAmmoCategories.find((string)defTemp["Category"]);
//CustomAmmoCategories.RegisterAmmunition((string)defTemp["Description"]["Id"], custCat);
defTemp["Category"] = custCat.BaseCategory.ToString();
ExtAmmunitionDef extAmmoDef = new ExtAmmunitionDef();
extAmmoDef.AmmoCategory = custCat;
if (defTemp["AccuracyModifier"] != null)
{
extAmmoDef.AccuracyModifier = (float)defTemp["AccuracyModifier"];
defTemp.Remove("AccuracyModifier");
}
if (defTemp["DamagePerShot"] != null)
{
extAmmoDef.DamagePerShot = (float)defTemp["DamagePerShot"];
defTemp.Remove("DamagePerShot");
}
if (defTemp["HeatDamagePerShot"] != null)
{
extAmmoDef.HeatDamagePerShot = (float)defTemp["HeatDamagePerShot"];
defTemp.Remove("HeatDamagePerShot");
}
if (defTemp["ProjectilesPerShot"] != null)
{
extAmmoDef.ProjectilesPerShot = (int)defTemp["ProjectilesPerShot"];
defTemp.Remove("ProjectilesPerShot");
}
if (defTemp["ShotsWhenFired"] != null)
{
extAmmoDef.ShotsWhenFired = (int)defTemp["ShotsWhenFired"];
defTemp.Remove("ShotsWhenFired");
}
if (defTemp["CriticalChanceMultiplier"] != null)
{
extAmmoDef.CriticalChanceMultiplier = (float)defTemp["CriticalChanceMultiplier"];
defTemp.Remove("CriticalChanceMultiplier");
}
if (defTemp["AIBattleValue"] != null)
{
extAmmoDef.AIBattleValue = (int)defTemp["AIBattleValue"];
defTemp.Remove("AIBattleValue");
}
if (defTemp["MinRange"] != null)
{
extAmmoDef.MinRange = (float)defTemp["MinRange"];
defTemp.Remove("MinRange");
}
if (defTemp["MaxRange"] != null)
{
extAmmoDef.MaxRange = (float)defTemp["MaxRange"];
defTemp.Remove("MaxRange");
}
if (defTemp["ShortRange"] != null)
{
extAmmoDef.ShortRange = (float)defTemp["ShortRange"];
defTemp.Remove("ShortRange");
}
if (defTemp["MediumRange"] != null)
{
extAmmoDef.MediumRange = (float)defTemp["MediumRange"];
defTemp.Remove("MediumRange");
}
if (defTemp["LongRange"] != null)
{
extAmmoDef.LongRange = (float)defTemp["LongRange"];
defTemp.Remove("LongRange");
}
if (defTemp["ForbiddenRange"] != null)
{
extAmmoDef.ForbiddenRange = (float)defTemp["ForbiddenRange"];
defTemp.Remove("ForbiddenRange");
}
if (defTemp["RefireModifier"] != null)
{
extAmmoDef.RefireModifier = (int)defTemp["RefireModifier"];
defTemp.Remove("RefireModifier");
}
if (defTemp["Instability"] != null)
{
extAmmoDef.Instability = (float)defTemp["Instability"];
defTemp.Remove("Instability");
}
if (defTemp["AttackRecoil"] != null)
{
extAmmoDef.AttackRecoil = (int)defTemp["AttackRecoil"];
defTemp.Remove("AttackRecoil");
}
if (defTemp["WeaponEffectID"] != null)
{
extAmmoDef.WeaponEffectID = (string)defTemp["WeaponEffectID"];
defTemp.Remove("WeaponEffectID");
}
if (defTemp["EvasivePipsIgnored"] != null)
{
extAmmoDef.EvasivePipsIgnored = (float)defTemp["EvasivePipsIgnored"];
defTemp.Remove("EvasivePipsIgnored");
}
if (defTemp["FlatJammingChance"] != null)
{
extAmmoDef.FlatJammingChance = (float)defTemp["FlatJammingChance"];
defTemp.Remove("FlatJammingChance");
}
if (defTemp["GunneryJammingBase"] != null)
{
extAmmoDef.GunneryJammingBase = (float)defTemp["GunneryJammingBase"];
defTemp.Remove("GunneryJammingBase");
}
if (defTemp["GunneryJammingMult"] != null)
{
extAmmoDef.GunneryJammingMult = (float)defTemp["GunneryJammingMult"];
defTemp.Remove("GunneryJammingMult");
}
if (defTemp["IndirectFireCapable"] != null)
{
extAmmoDef.IndirectFireCapable = ((bool)defTemp["IndirectFireCapable"] == true) ? TripleBoolean.True : TripleBoolean.False;
defTemp.Remove("IndirectFireCapable");
}
if (defTemp["DirectFireModifier"] != null)
{
extAmmoDef.DirectFireModifier = (float)defTemp["DirectFireModifier"];
defTemp.Remove("DirectFireModifier");
}
if (defTemp["AOECapable"] != null)
{
extAmmoDef.AOECapable = ((bool)defTemp["AOECapable"] == true) ? TripleBoolean.True : TripleBoolean.False;
defTemp.Remove("AOECapable");
}
if (defTemp["DistantVariance"] != null)
{
extAmmoDef.DistantVariance = (float)defTemp["DistantVariance"];
defTemp.Remove("DistantVariance");
}
if (defTemp["AlwaysIndirectVisuals"] != null)
{
extAmmoDef.AlwaysIndirectVisuals = ((bool)defTemp["AlwaysIndirectVisuals"] == true) ? TripleBoolean.True : TripleBoolean.False;
defTemp.Remove("AlwaysIndirectVisuals");
}
if (defTemp["DamageMultiplier"] != null)
{
extAmmoDef.DamageMultiplier = (float)defTemp["DamageMultiplier"];
defTemp.Remove("DamageMultiplier");
}
if (defTemp["DistantVarianceReversed"] != null)
{
extAmmoDef.DistantVarianceReversed = ((bool)defTemp["DistantVarianceReversed"] == true) ? TripleBoolean.True : TripleBoolean.False;
defTemp.Remove("DistantVarianceReversed");
}
if (defTemp["DamageVariance"] != null)
{
extAmmoDef.DamageVariance = (float)defTemp["DamageVariance"];
defTemp.Remove("DamageVariance");
}
if (defTemp["HitGenerator"] != null)
{
try {
extAmmoDef.HitGenerator = (HitGeneratorType)Enum.Parse(typeof(HitGeneratorType), (string)defTemp["HitGenerator"], true);
} catch (Exception e) {
extAmmoDef.HitGenerator = HitGeneratorType.NotSet;
}
defTemp.Remove("HitGenerator");
}
if (defTemp["statusEffects"] != null)
{
if (defTemp["statusEffects"].Type == JTokenType.Array)
{
List <EffectData> tmpList = new List <EffectData>();
JToken statusEffects = defTemp["statusEffects"];
foreach (JObject statusEffect in statusEffects)
{
EffectData effect = new EffectData();
JSONSerializationUtility.FromJSON <EffectData>(effect, statusEffect.ToString());
tmpList.Add(effect);
}
extAmmoDef.statusEffects = tmpList.ToArray();
}
//extAmmoDef.statusEffects = JsonConvert.DeserializeObject<EffectData[]>(defTemp["statusEffects"].ToString());
//JSONSerializationUtility.FromJSON<EffectData[]>(extAmmoDef.statusEffects, defTemp["statusEffects"].ToString());
//CustomAmmoCategoriesLog.Log.LogWrite(JsonConvert.SerializeObject(extAmmoDef.statusEffects)+"\n");
defTemp.Remove("statusEffects");
}
CustomAmmoCategories.RegisterExtAmmoDef((string)defTemp["Description"]["Id"], extAmmoDef);
json = defTemp.ToString();
return(true);
}
