public static MinMaxRange CalculateDamageConversion(ActorData data, int[] convertedDamageMin,
int[] convertedDamageMax, IEnumerable <GroupType> tags,
MinMaxRange damageContainer, float[] conversions, ElementType element,
HashSet <BonusType> multi, StatBonus minBonus, StatBonus maxBonus, StatBonus multiplierBonus)
{
float baseMin = damageContainer.min + minBonus.CalculateStat(0);
float baseMax = damageContainer.max + maxBonus.CalculateStat(0);
float finalBaseMin = baseMin;
float finalBaseMax = baseMax;
for (int i = 0; i < 7; i++)
{
if (conversions[i] == 0)
{
continue;
}
float convertedMin = baseMin * conversions[i];
float convertedMax = baseMax * conversions[i];
finalBaseMin -= convertedMin;
finalBaseMax -= convertedMax;
HashSet <BonusType> bonusesForConverted = new HashSet <BonusType>(multi);
bonusesForConverted.UnionWith(Helpers.GetMultiplierTypes(AbilityType.NON_ABILITY, element, (ElementType)i));
StatBonus totalMultiplierBonus = data.GetMultiStatBonus(null, tags, bonusesForConverted.ToArray());
totalMultiplierBonus.AddBonuses(multiplierBonus);
convertedMin = totalMultiplierBonus.CalculateStat(convertedMin);
convertedMax = totalMultiplierBonus.CalculateStat(convertedMax);
convertedDamageMin[i] += (int)Math.Max(convertedMin, 0);
convertedDamageMax[i] += (int)Math.Max(convertedMax, 0);
}
MinMaxRange returnValue = new MinMaxRange();
if (finalBaseMin < 1)
{
finalBaseMin = 0;
}
if (finalBaseMax < 1)
{
finalBaseMax = 0;
}
if (finalBaseMax == 0 && finalBaseMin == 0)
{
returnValue.min = 0;
returnValue.max = 0;
}
else
{
StatBonus finalMultiplier = data.GetMultiStatBonus(null, tags, multi.ToArray());
finalMultiplier.AddBonuses(multiplierBonus);
returnValue.min = (int)Math.Max(finalMultiplier.CalculateStat(finalBaseMin), 0);
returnValue.max = (int)Math.Max(finalMultiplier.CalculateStat(finalBaseMax), 0);
}
return(returnValue);
}
/// <summary>
/// Loads in the selected Parade Configuration preset
/// </summary>
private void loadConfigurationPreset()
{
if (configurationPreset != null)
{
currentConfigName = configurationPreset.ConfigName;
Camera.main.gameObject.GetComponent <MouseLook>().MouseLookEnabled = configurationPreset.EnableMouseLook;
enableTestUI = configurationPreset.EnableTestUI;
testBlocksToTravel = configurationPreset.NumberOfTestBlocks;
bufferLeadDistanceInBlocks = configurationPreset.LeadingBlocks;
bufferCleanupDistance = configurationPreset.RearCleanupDistance;
testCameraSpeed = configurationPreset.CameraSpeed;
generateRoads = configurationPreset.GenerateRoads;
generateBuildings = configurationPreset.GenerateBuildings;
generateCrowds = configurationPreset.GenerateCrowds;
crowdDensityFactor = configurationPreset.CrowdDensity;
balloonChance = configurationPreset.BalloonChance;
balloonLetGoChance = configurationPreset.BalloonLetGoChance;
randomizedPersonTimeOffset = configurationPreset.RandomizedTimeOffset;
distractionCheckFrequency = configurationPreset.DistractionCheckFrequency;
distractionDuration = configurationPreset.DistractionDuration;
behaviourChangeInterval = configurationPreset.BehaviourChangeInterval;
makeFancyBuildings = configurationPreset.MakeFancyBuildings;
numberOfBuildingStoreys = configurationPreset.NumberOfBuildingStoreys;
}
else
{
currentConfigName = "[Test Configuration]";
}
runningCappedTest = (testBlocksToTravel == 0) ? false : true;
cityMovementSpeed = testCameraSpeed;
}
private void Reset()
{
if (bgmGO == null)
{
bgmGO = new GameObject("BGM Audio Source");
bgmGO.transform.SetParent(transform);
bgmGO.transform.localPosition = Vector3.zero;
bgmGO.transform.localRotation = Quaternion.identity;
bgmGO.transform.localScale = Vector3.one;
bgmAudioSource = bgmGO.AddComponent <AudioSource>();
}
if (sfxGO == null)
{
sfxGO = new GameObject("SFX Audio Source");
sfxGO.transform.SetParent(transform);
sfxGO.transform.localPosition = Vector3.zero;
sfxGO.transform.localRotation = Quaternion.identity;
sfxGO.transform.localScale = Vector3.one;
sfxAudioSource = sfxGO.AddComponent <AudioSource>();
}
if (voiceGO == null)
{
voiceGO = new GameObject("Voice Audio Source");
voiceGO.transform.SetParent(transform);
voiceGO.transform.localPosition = Vector3.zero;
voiceGO.transform.localRotation = Quaternion.identity;
voiceGO.transform.localScale = Vector3.one;
voiceAudioSource = voiceGO.AddComponent <AudioSource>();
}
volumeRange_dB = new MinMaxRange();
volumeRange_dB.min = -80f;
volumeRange_dB.max = 0f;
}
public Weapon(EquipmentBase e, int ilvl) : base(e, ilvl)
{
weaponDamage = new Dictionary <ElementType, MinMaxRange>();
foreach (ElementType element in Enum.GetValues(typeof(ElementType)))
{
weaponDamage[element] = new MinMaxRange();
}
weaponDamage[ElementType.PHYSICAL].SetMinMax(e.minDamage, e.maxDamage);
CriticalChance = e.criticalChance;
AttackSpeed = e.attackSpeed;
WeaponRange = e.weaponRange;
}
protected void UpdateDamage(EnemyData data, Dictionary <ElementType, AbilityDamageBase> damageLevels, IEnumerable <GroupType> tags, float damageModifier = 1.0f)
{
if (abilityBase.abilityType == AbilityType.AURA || abilityBase.abilityType == AbilityType.SELF_BUFF)
{
return;
}
int[] mainConvertedDamageMin = new int[7];
int[] mainConvertedDamageMax = new int[7];
float flatDamageMod = abilityBase.flatDamageMultiplier;
AbilityType abilityType = abilityBase.abilityType;
foreach (ElementType element in Enum.GetValues(typeof(ElementType)))
{
mainDamageBase[element].baseMin = 0;
mainDamageBase[element].baseMax = 0;
MinMaxRange abilityBaseDamage;
if (damageLevels.ContainsKey(element))
{
abilityBaseDamage = damageLevels[element].damage[abilityLevel];
}
else
{
abilityBaseDamage = new MinMaxRange();
}
if (abilityBase.abilityType == AbilityType.ATTACK && element == ElementType.PHYSICAL)
{
flatDamageMod = abilityBase.weaponMultiplier + abilityBase.weaponMultiplierScaling * 50;
mainDamageBase[element].baseMin = (abilityBaseDamage.min + data.minAttackDamage) * flatDamageMod;
mainDamageBase[element].baseMax = (abilityBaseDamage.max + data.maxAttackDamage) * flatDamageMod;
}
else
{
mainDamageBase[element].baseMin = abilityBaseDamage.min;
mainDamageBase[element].baseMax = abilityBaseDamage.max;
}
IList <GroupType> damageTags = abilityBase.GetGroupTypes();
HashSet <GroupType> mainHandTags = AbilityOwner.GetActorTagsAndDataTags();
HashSet <BonusType> min = new HashSet <BonusType>();
HashSet <BonusType> max = new HashSet <BonusType>();
HashSet <BonusType> multi = new HashSet <BonusType>();
Helpers.GetGlobalAndFlatDamageTypes(element, abilityBase.abilityType, abilityBase.abilityShotType, damageTags, min, max, multi);
multi.UnionWith(Helpers.GetMultiplierTypes(abilityBase.abilityType, element));
mainDamageBase[element].ClearBonuses();
data.GetMultiStatBonus(mainDamageBase[element].minBonus, abilityBonuses, mainHandTags, min.ToArray());
data.GetMultiStatBonus(mainDamageBase[element].maxBonus, abilityBonuses, mainHandTags, max.ToArray());
data.GetMultiStatBonus(mainDamageBase[element].multiplierBonus, abilityBonuses, mainHandTags, multi.ToArray());
mainDamageBase[element].CalculateRange(flatDamageMod, finalDamageModifier);
//Debug.Log(mainDamageBase[element].calculatedRange.min + " " + mainDamageBase[element].calculatedRange.max + " " + element);
}
}
/// <summary>
/// Calculates Elemental Conversions. Each element is run once so conversion chains cannot happen.
/// After conversion, the converted damage is calculated with all multiplier bonuses and
/// is added to an array. Afterwards it should be added to the main damage dictionary/array.
/// </summary>
/// <param name="data"></param>
/// <param name="flatDamageMod"></param>
/// <param name="convertedDamageMin"></param>
/// <param name="convertedDamageMax"></param>
/// <param name="tags"></param>
/// <param name="damageContainer"></param>
/// <param name="element"></param>
/// <param name="multi"></param>
/// <param name="minBonus"></param>
/// <param name="maxBonus"></param>
/// <param name="multiplierBonus"></param>
/// <returns></returns>
private MinMaxRange CalculateDamageConversion(ActorData data, float flatDamageMod, int[] convertedDamageMin,
int[] convertedDamageMax, IEnumerable <GroupType> tags,
AbilityDamageContainer damageContainer, ElementType element,
HashSet <BonusType> multi, StatBonus minBonus = null, StatBonus maxBonus = null, StatBonus multiplierBonus = null)
{
float baseMin, baseMax;
if (minBonus != null)
{
baseMin = damageContainer.baseMin + minBonus.CalculateStat(0) * flatDamageMod;
}
else
{
baseMin = damageContainer.baseMin + damageContainer.minBonus.CalculateStat(0) * flatDamageMod;
}
if (maxBonus != null)
{
baseMax = damageContainer.baseMax + maxBonus.CalculateStat(0) * flatDamageMod;
}
else
{
baseMax = damageContainer.baseMax + damageContainer.maxBonus.CalculateStat(0) * flatDamageMod;
}
float finalBaseMin = baseMin;
float finalBaseMax = baseMax;
for (int i = 0; i < 7; i++)
{
if (damageContainer.conversions[i] == 0)
{
continue;
}
float convertedMin = baseMin * damageContainer.conversions[i];
float convertedMax = baseMax * damageContainer.conversions[i];
finalBaseMin -= convertedMin;
finalBaseMax -= convertedMax;
HashSet <BonusType> bonusesForConverted = new HashSet <BonusType>(multi);
bonusesForConverted.UnionWith(Helpers.GetMultiplierTypes(abilityBase.abilityType, element, (ElementType)i));
StatBonus totalMultiplierBonus = data.GetMultiStatBonus(abilityBonuses, tags, bonusesForConverted.ToArray());
totalMultiplierBonus.AddBonuses(multiplierBonus);
convertedMin = totalMultiplierBonus.CalculateStat(convertedMin);
convertedMax = totalMultiplierBonus.CalculateStat(convertedMax);
convertedDamageMin[i] += (int)Math.Max(convertedMin * finalDamageModifier, 0);
convertedDamageMax[i] += (int)Math.Max(convertedMax * finalDamageModifier, 0);
}
MinMaxRange returnValue = new MinMaxRange();
if (finalBaseMin < 1)
{
finalBaseMin = 0;
}
if (finalBaseMax < 1)
{
finalBaseMax = 0;
}
if (finalBaseMax == 0 && finalBaseMin == 0)
{
returnValue.min = 0;
returnValue.max = 0;
}
else
{
StatBonus finalMultiplier = data.GetMultiStatBonus(abilityBonuses, tags, multi.ToArray());
finalMultiplier.AddBonuses(multiplierBonus);
returnValue.min = (int)Math.Max(finalMultiplier.CalculateStat(finalBaseMin) * finalDamageModifier, 0);
returnValue.max = (int)Math.Max(finalMultiplier.CalculateStat(finalBaseMax) * finalDamageModifier, 0);
}
return(returnValue);
}
protected void UpdateDamage(HeroData data, Dictionary <ElementType, AbilityDamageBase> damageLevels, IEnumerable <GroupType> tags)
{
if (abilityBase.abilityType == AbilityType.AURA || abilityBase.abilityType == AbilityType.SELF_BUFF)
{
return;
}
IList <GroupType> damageTags = abilityBase.GetGroupTypes();
Weapon mainWeapon = null, offWeapon = null;
float flatDamageMod = abilityBase.flatDamageMultiplier;
DualWielding = false;
int[] mainConvertedDamageMin = new int[7];
int[] mainConvertedDamageMax = new int[7];
int[] offConvertedDamageMin = new int[7];
int[] offConvertedDamageMax = new int[7];
if (data.GetEquipmentInSlot(EquipSlotType.WEAPON) is Weapon)
{
mainWeapon = data.GetEquipmentInSlot(EquipSlotType.WEAPON) as Weapon;
}
if (data.GetEquipmentInSlot(EquipSlotType.OFF_HAND) is Weapon)
{
offWeapon = data.GetEquipmentInSlot(EquipSlotType.OFF_HAND) as Weapon;
DualWielding = true;
}
HashSet <GroupType> nonWeaponTags = data.GetGroupTypes(false);
HashSet <GroupType> mainHandTags = new HashSet <GroupType>(nonWeaponTags);
if (mainWeapon != null)
{
mainHandTags.UnionWith(mainWeapon.GetGroupTypes());
if (DualWielding && !AlternatesAttacks || DualWielding && abilityBase.abilityType == AbilityType.SPELL)
{
mainHandTags.UnionWith(offWeapon.GetGroupTypes());
}
}
foreach (ElementType element in Enum.GetValues(typeof(ElementType)))
{
float offMinDamage = 0, offMaxDamage = 0, baseMinDamage = 0, baseMaxDamage = 0;
if (damageLevels.ContainsKey(element))
{
MinMaxRange abilityBaseDamage = damageLevels[element].damage[abilityLevel];
baseMinDamage = abilityBaseDamage.min;
baseMaxDamage = abilityBaseDamage.max;
}
float mainMaxDamage;
float mainMinDamage;
if (abilityBase.abilityType == AbilityType.ATTACK)
{
float weaponMulti = abilityBase.weaponMultiplier + abilityBase.weaponMultiplierScaling * abilityLevel;
flatDamageMod = weaponMulti;
if (mainWeapon != null)
{
MinMaxRange mainWeaponDamage = mainWeapon.GetWeaponDamage(element);
mainMinDamage = (mainWeaponDamage.min + baseMinDamage) * weaponMulti;
mainMaxDamage = (mainWeaponDamage.max + baseMaxDamage) * weaponMulti;
if (DualWielding)
{
MinMaxRange offWeaponDamage = offWeapon.GetWeaponDamage(element);
offMinDamage = (offWeaponDamage.min + baseMinDamage) * weaponMulti;
offMaxDamage = (offWeaponDamage.max + baseMaxDamage) * weaponMulti;
offhandDamageBase[element].baseMin = offMinDamage;
offhandDamageBase[element].baseMax = offMaxDamage;
if (!AlternatesAttacks)
{
mainMinDamage = (mainMinDamage + offMinDamage) * 0.5f;
mainMaxDamage = (mainMaxDamage + offMaxDamage) * 0.5f;
}
}
}
else
{
if (element == ElementType.PHYSICAL)
{
baseMinDamage += 4;
baseMaxDamage += 9;
}
mainMinDamage = baseMinDamage * weaponMulti;
mainMaxDamage = baseMaxDamage * weaponMulti;
}
}
else
{
mainMinDamage = baseMinDamage;
mainMaxDamage = baseMaxDamage;
}
mainDamageBase[element].baseMin = mainMinDamage;
mainDamageBase[element].baseMax = mainMaxDamage;
//Helpers.GetDamageTypes(element, abilityType, abilityBase.abilityShotType, damageTags, min, max, multi);
HashSet <BonusType> min = new HashSet <BonusType>();
HashSet <BonusType> max = new HashSet <BonusType>();
HashSet <BonusType> multi = new HashSet <BonusType>();
Helpers.GetGlobalAndFlatDamageTypes(element, abilityBase.abilityType, abilityBase.abilityShotType, damageTags, min, max, multi);
multi.UnionWith(Helpers.GetMultiplierTypes(abilityBase.abilityType, element));
mainDamageBase[element].ClearBonuses();
data.GetMultiStatBonus(mainDamageBase[element].minBonus, abilityBonuses, mainHandTags, min.ToArray());
data.GetMultiStatBonus(mainDamageBase[element].maxBonus, abilityBonuses, mainHandTags, max.ToArray());
data.GetMultiStatBonus(mainDamageBase[element].multiplierBonus, abilityBonuses, mainHandTags, multi.ToArray());
HashSet <BonusType> availableConversions = data.BonusesIntersection(abilityBonuses.Keys, Helpers.GetConversionTypes(element));
if (availableConversions.Count > 0)
{
GetElementConversionValues(data, mainHandTags, availableConversions, mainDamageBase[element].conversions, abilityBonuses);
MinMaxRange baseRange = CalculateDamageConversion(data, flatDamageMod, mainConvertedDamageMin, mainConvertedDamageMax, mainHandTags, mainDamageBase[element], element, multi);
mainDamageBase[element].calculatedRange.min = baseRange.min;
mainDamageBase[element].calculatedRange.max = baseRange.max;
}
else
{
mainDamageBase[element].CalculateRange(flatDamageMod, finalDamageModifier);
}
if (DualWielding && AlternatesAttacks)
{
HashSet <GroupType> offHandTags = new HashSet <GroupType>(nonWeaponTags);
offHandTags.UnionWith(offWeapon.GetGroupTypes());
offhandDamageBase[element].ClearBonuses();
data.GetMultiStatBonus(offhandDamageBase[element].minBonus, abilityBonuses, offHandTags, min.ToArray());
data.GetMultiStatBonus(offhandDamageBase[element].maxBonus, abilityBonuses, offHandTags, max.ToArray());
multi.UnionWith(Helpers.GetMultiplierTypes(abilityBase.abilityType, element));
data.GetMultiStatBonus(offhandDamageBase[element].multiplierBonus, abilityBonuses, offHandTags, multi.ToArray());
availableConversions = data.BonusesIntersection(abilityBonuses.Keys, Helpers.GetConversionTypes(element));
if (availableConversions.Count > 0)
{
GetElementConversionValues(data, offHandTags, availableConversions, offhandDamageBase[element].conversions, abilityBonuses);
MinMaxRange baseRange = CalculateDamageConversion(data, flatDamageMod, offConvertedDamageMin, offConvertedDamageMax, offHandTags, offhandDamageBase[element], element, multi);
offhandDamageBase[element].calculatedRange.min = Math.Max(baseRange.min, 0);
offhandDamageBase[element].calculatedRange.max = Math.Max(baseRange.max, 0);
}
else
{
offhandDamageBase[element].CalculateRange(flatDamageMod, finalDamageModifier);
}
}
}
foreach (ElementType element in Enum.GetValues(typeof(ElementType)))
{
mainDamageBase[element].calculatedRange.min += mainConvertedDamageMin[(int)element];
mainDamageBase[element].calculatedRange.max += mainConvertedDamageMax[(int)element];
if (DualWielding && AlternatesAttacks)
{
offhandDamageBase[element].calculatedRange.min += offConvertedDamageMin[(int)element];
offhandDamageBase[element].calculatedRange.max += offConvertedDamageMax[(int)element];
}
}
}
// Extract non-MS data from the specified file path, with UV spectra limited to at
// most the specified number.
private void ExtractNonMSData(string dataFilePath, int maxSpectraToReport)
{
IMsdrDataReader dataReader = new MassSpecDataReader();
dataReader.OpenDataFile(dataFilePath);
INonmsDataReader nonMsReader = dataReader as INonmsDataReader;
IDeviceInfo[] deviceInfo = nonMsReader.GetNonmsDevices();
if ((deviceInfo == null) || (deviceInfo.Length == 0))
{
println("No Non MS device found");
}
else
{
foreach (IDeviceInfo device in deviceInfo)
{
println("Device = " + device.DeviceName + " Ordinal number = " + device.OrdinalNumber.ToString() + " Device type = " + device.DeviceType.ToString());
#region DAD Signal & Spectrum
if (device.DeviceType == DeviceType.DiodeArrayDetector ||
device.DeviceType == DeviceType.HDR ||
device.DeviceType == DeviceType.CompactLC1220DAD)
{
//Extracting Signal Information
ISignalInfo[] sigInfo = nonMsReader.GetSignalInfo(device, StoredDataType.Chromatograms);
if (sigInfo.Length == 0)
{
println("No DAD signal found");
}
else
{
StringBuilder sb = new StringBuilder();
sb.AppendFormat("Found info on {0} signals: ", sigInfo.Length);
foreach (ISignalInfo info in sigInfo)
{
sb.AppendFormat("{0}, ", info.SignalName);
}
println(sb.ToString());
IBDAChromData chromData = nonMsReader.GetSignal(sigInfo[0]);
if ((chromData == null) || (chromData.TotalDataPoints == 0))
{
println("No data found for first DAD signal");
}
else
{
int count = chromData.TotalDataPoints;
double[] xArray = chromData.XArray;
float[] yArray = chromData.YArray;
// This information can be exported to a file on disk
FileStream file = new FileStream(@"C:\temp\reportNew.csv", FileMode.Create, FileAccess.ReadWrite);
TextWriter sw = new StreamWriter(file);
sw.WriteLine("#Point,X(Minutes),Y(Response Units)");
for (int i = 0; i < xArray.Length; i++)
{
sw.WriteLine(i.ToString() + "," + xArray[i].ToString() + "," + yArray[i].ToString());
}
sw.Close();
file.Close();
}
}
//Extracting TWC
IBDAChromData chromDataTWC = nonMsReader.GetTWC(device);
//compare this data with our own file
if ((chromDataTWC == null) || (chromDataTWC.TotalDataPoints == 0))
{
println("No TWC found");
}
else
{
int dataPoints = chromDataTWC.TotalDataPoints;
double[] xArrayTWC = chromDataTWC.XArray;
float[] yArrayTWC = chromDataTWC.YArray;
// Expoting this information to a file on disk
FileStream fileTWC = new FileStream(@"C:\temp\reportTWC.csv", FileMode.Create, FileAccess.ReadWrite);
TextWriter swTWC = new StreamWriter(fileTWC);
swTWC.WriteLine("#Point,X(Minutes),Y(Response Units)");
for (int i = 0; i < xArrayTWC.Length; i++)
{
swTWC.WriteLine(i.ToString() + "," + xArrayTWC[i].ToString() + "," + yArrayTWC[i].ToString());
}
swTWC.Close();
fileTWC.Close();
}
//Extracting EWC
IRange rangeSignal = new MinMaxRange(40, 250);
IRange rangeRef = new MinMaxRange(40, 250);
IBDAChromData chromDataEWC = nonMsReader.GetEWC(device, rangeSignal, rangeRef);
if ((chromDataEWC == null) || (chromDataEWC.TotalDataPoints == 0))
{
println("No EWC found");
}
else
{
double[] xArrayEWC = chromDataEWC.XArray;
float[] yArrayEWC = chromDataEWC.YArray;
// Expoting this information to a file on disk
FileStream fileEWC = new FileStream(@"C:\temp\reportEWC.csv", FileMode.Create, FileAccess.ReadWrite);
TextWriter swEWC = new StreamWriter(fileEWC);
swEWC.WriteLine("#Point,X(Minutes),Y(Response Units)");
for (int i = 0; i < xArrayEWC.Length; i++)
{
swEWC.WriteLine(i.ToString() + "," + xArrayEWC[i].ToString() + "," + yArrayEWC[i].ToString());
}
swEWC.Close();
fileEWC.Close();
}
//UV Spectrum: get each UV spectrum in the file
string uvSpectraFilePath = @"C:\temp\reportUV.csv";
if (File.Exists(uvSpectraFilePath))
{
File.Delete(uvSpectraFilePath);
}
for (int k = 0; k < chromDataTWC.XArray.Length && k < maxSpectraToReport; k++)
{
IRange range = new MinMaxRange(chromDataTWC.XArray[k], chromDataTWC.XArray[k]);
IBDASpecData[] uvSpecData = nonMsReader.GetUVSpectrum(device, range);
if (uvSpecData == null)
{
println("No UV spectrum found");
}
else
{
foreach (IBDASpecData uvSpec in uvSpecData)
{
if (uvSpec.TotalDataPoints != 0)
{
int dataPopints = uvSpec.TotalDataPoints;
double[] xArrayUV = uvSpec.XArray;
float[] yArrayUV = uvSpec.YArray;
// Expoting this information to a file on disk
FileStream fileUV = new FileStream(uvSpectraFilePath, FileMode.Append,
FileAccess.Write);
TextWriter swUV = new StreamWriter(fileUV);
swUV.WriteLine("#Point,X(Nanometers),Y(mAU)");
for (int i = 0; i < xArrayUV.Length; i++)
{
swUV.WriteLine(i.ToString() + "," + xArrayUV[i].ToString() + "," +
yArrayUV[i].ToString());
}
swUV.Close();
fileUV.Close();
}
else
{
println("No UV spectrum found");
}
}
}
}
}
#endregion
#region InstrumentCurves - TCC
if (device.DeviceType == DeviceType.ThermostattedColumnCompartment)
{
ISignalInfo[] sigInfo = nonMsReader.GetSignalInfo(device, StoredDataType.InstrumentCurves);
if (sigInfo.Length == 0)
{
println("No TCC Curves found");
}
else
{
IBDAChromData chromData = nonMsReader.GetSignal(sigInfo[0]);
if ((chromData == null) || (chromData.TotalDataPoints == 0))
{
println("No TCC Curves found");
}
else
{
int count = chromData.TotalDataPoints;
double[] xArray = chromData.XArray;
float[] yArray = chromData.YArray;
// Expoting this information to a file on disk
FileStream file = new FileStream(@"C:\temp\reportInstrumentCurve.csv", FileMode.Create, FileAccess.ReadWrite);
TextWriter sw = new StreamWriter(file);
sw.WriteLine("#Point,X(Minutes),Y(Response Units)");
for (int i = 0; i < xArray.Length; i++)
{
sw.WriteLine(i.ToString() + "," + xArray[i].ToString() + "," + yArray[i].ToString());
}
sw.Close();
file.Close();
}
}
}
#endregion
}
}
}
public Dictionary <ElementType, float> ScaleSecondaryDamageValue(Actor target, Dictionary <ElementType, MinMaxRange> baseDamage, IEnumerable <GroupType> effectTags)
{
HashSet <GroupType> targetTypes = target.GetActorTagsAsTarget();
Dictionary <BonusType, StatBonus> whenHitBonusDict = new Dictionary <BonusType, StatBonus>();
int[] minDamage = new int[7];
int[] maxDamage = new int[7];
int[] convertedMinDamage = new int[7];
int[] convertedMaxDamage = new int[7];
float[] conversions = new float[7];
HashSet <GroupType> tagsToUse = new HashSet <GroupType>(effectTags);
tagsToUse.UnionWith(GetActorTagsAndDataTags());
foreach (TriggeredEffect triggeredEffect in Data.TriggeredEffects[TriggerType.WHEN_HITTING])
{
if (targetTypes.Contains(triggeredEffect.BaseEffect.restriction) && triggeredEffect.RollTriggerChance())
{
if (whenHitBonusDict.ContainsKey(triggeredEffect.BaseEffect.statBonusType))
{
whenHitBonusDict[triggeredEffect.BaseEffect.statBonusType].AddBonus(triggeredEffect.BaseEffect.statModifyType, triggeredEffect.Value);
}
else
{
StatBonus bonus = new StatBonus();
bonus.AddBonus(triggeredEffect.BaseEffect.statModifyType, triggeredEffect.Value);
whenHitBonusDict.Add(triggeredEffect.BaseEffect.statBonusType, bonus);
}
}
}
foreach (ElementType elementType in Enum.GetValues(typeof(ElementType)))
{
if (!baseDamage.ContainsKey(elementType))
{
baseDamage[elementType] = new MinMaxRange();
}
minDamage[(int)elementType] = baseDamage[elementType].min;
maxDamage[(int)elementType] = baseDamage[elementType].max;
HashSet <BonusType> minTypes = new HashSet <BonusType>();
HashSet <BonusType> maxTypes = new HashSet <BonusType>();
HashSet <BonusType> multiTypes = new HashSet <BonusType>();
Helpers.GetGlobalAndFlatDamageTypes(elementType, tagsToUse, minTypes, maxTypes, multiTypes);
multiTypes.UnionWith(Helpers.GetMultiplierTypes(AbilityType.NON_ABILITY, elementType));
StatBonus minBonus = Data.GetMultiStatBonus(tagsToUse, minTypes.ToArray());
StatBonus maxBonus = Data.GetMultiStatBonus(tagsToUse, maxTypes.ToArray());
StatBonus multiBonus = new StatBonus();
foreach (KeyValuePair <BonusType, StatBonus> keyValue in whenHitBonusDict)
{
if (minTypes.Contains(keyValue.Key))
{
minBonus.AddBonuses(keyValue.Value);
}
else if (maxTypes.Contains(keyValue.Key))
{
maxBonus.AddBonuses(keyValue.Value);
}
else if (multiTypes.Contains(keyValue.Key))
{
multiBonus.AddBonuses(keyValue.Value);
}
}
HashSet <BonusType> availableConversions = Data.BonusesIntersection(null, Helpers.GetConversionTypes(elementType));
if (availableConversions.Count > 0)
{
Array.Clear(conversions, 0, 7);
ActorAbility.GetElementConversionValues(Data, tagsToUse, availableConversions, conversions, null);
MinMaxRange baseRange = ActorAbility.CalculateDamageConversion(Data, convertedMinDamage, convertedMaxDamage, tagsToUse, baseDamage[elementType], conversions, elementType, multiTypes, minBonus, maxBonus, multiBonus);
minDamage[(int)elementType] = baseRange.min;
maxDamage[(int)elementType] = baseRange.max;
}
else
{
Data.GetMultiStatBonus(multiBonus, null, tagsToUse, multiTypes.ToArray());
minDamage[(int)elementType] = (int)Math.Max(multiBonus.CalculateStat(baseDamage[elementType].min + minBonus.CalculateStat(0f)), 0);
maxDamage[(int)elementType] = (int)Math.Max(multiBonus.CalculateStat(baseDamage[elementType].max + maxBonus.CalculateStat(0f)), 0);
}
}
float critChance = Data.GetMultiStatBonus(tagsToUse, BonusType.GLOBAL_CRITICAL_CHANCE).CalculateStat(0f);
bool isCrit = UnityEngine.Random.Range(0f, 100f) < critChance;
Dictionary <ElementType, float> returnDict = new Dictionary <ElementType, float>();
foreach (ElementType elementType in Enum.GetValues(typeof(ElementType)))
{
float damage = UnityEngine.Random.Range(minDamage[(int)elementType] + convertedMinDamage[(int)elementType], maxDamage[(int)elementType] + convertedMaxDamage[(int)elementType] + 1);
if (isCrit)
{
damage *= 1 + (Data.GetMultiStatBonus(tagsToUse, BonusType.GLOBAL_CRITICAL_DAMAGE).CalculateStat(50) / 100f);
}
returnDict.Add(elementType, damage);
}
return(returnDict);
}
/// <summary>
/// To extract non MS data
/// </summary>
private void ExtractNonMSData()
{
IMsdrDataReader dataReader = new MassSpecDataReader();
dataReader.OpenDataFile(_NonMSdataFilename);
INonmsDataReader nonMsReader = dataReader as INonmsDataReader;
IDeviceInfo[] deviceInfo = nonMsReader.GetNonmsDevices();
if ((deviceInfo == null) || (deviceInfo.Length == 0))
{
println("No Non MS device found");
}
else
{
foreach (IDeviceInfo device in deviceInfo)
{
println("Device = " + device.DeviceName + " Ordinal number = " + device.OrdinalNumber.ToString() + " Device type = " + device.DeviceType.ToString());
#region DAD Signal & Spectrum
if (device.DeviceType == DeviceType.DiodeArrayDetector)
{
//Extracting Signal Information
ISignalInfo[] sigInfo = nonMsReader.GetSignalInfo(device, StoredDataType.Chromatograms);
if (sigInfo.Length == 0)
{
println("No DAD signal found");
}
else
{
IBDAChromData chromData = nonMsReader.GetSignal(sigInfo[0]);
if ((chromData == null) || (chromData.TotalDataPoints == 0))
{
println("No DAD signal found");
}
else
{
int count = chromData.TotalDataPoints;
double[] xArray = chromData.XArray;
float[] yArray = chromData.YArray;
// This information can be exported to a file on disk
FileStream file = new FileStream(@"C:\temp\reportNew.csv", FileMode.Create, FileAccess.ReadWrite);
TextWriter sw = new StreamWriter(file);
sw.WriteLine("#Point,X(Minutes),Y(Response Units)");
for (int i = 0; i < xArray.Length; i++)
{
sw.WriteLine(i.ToString() + "," + xArray[i].ToString() + "," + yArray[i].ToString());
}
sw.Close();
file.Close();
}
}
//Extracting TWC
IBDAChromData chromDataTWC = nonMsReader.GetTWC(device);
//compare this data with our own file
if ((chromDataTWC == null) || (chromDataTWC.TotalDataPoints == 0))
{
println("No TWC found");
}
else
{
int dataPoints = chromDataTWC.TotalDataPoints;
double[] xArrayTWC = chromDataTWC.XArray;
float[] yArrayTWC = chromDataTWC.YArray;
// Expoting this information to a file on disk
FileStream fileTWC = new FileStream(@"C:\temp\reportTWC.csv", FileMode.Create, FileAccess.ReadWrite);
TextWriter swTWC = new StreamWriter(fileTWC);
swTWC.WriteLine("#Point,X(Minutes),Y(Response Units)");
for (int i = 0; i < xArrayTWC.Length; i++)
{
swTWC.WriteLine(i.ToString() + "," + xArrayTWC[i].ToString() + "," + yArrayTWC[i].ToString());
}
swTWC.Close();
fileTWC.Close();
}
//Extracting EWC
IRange rangeSignal = new MinMaxRange(40, 250);
IRange rangeRef = new MinMaxRange(40, 250);
IBDAChromData chromDataEWC = nonMsReader.GetEWC(device, rangeSignal, rangeRef);
if ((chromDataEWC == null) || (chromDataEWC.TotalDataPoints == 0))
{
println("No EWC signal found");
}
else
{
int dataPointsEWC = chromDataEWC.TotalDataPoints;
double[] xArrayEWC = chromDataEWC.XArray;
float[] yArrayEWC = chromDataEWC.YArray;
// Expoting this information to a file on disk
FileStream fileEWC = new FileStream(@"C:\temp\reportEWC.csv", FileMode.Create, FileAccess.ReadWrite);
TextWriter swEWC = new StreamWriter(fileEWC);
swEWC.WriteLine("#Point,X(Minutes),Y(Response Units)");
for (int i = 0; i < xArrayEWC.Length; i++)
{
swEWC.WriteLine(i.ToString() + "," + xArrayEWC[i].ToString() + "," + yArrayEWC[i].ToString());
}
swEWC.Close();
fileEWC.Close();
}
//UV Spectrum
IRange range = new MinMaxRange(1.109, 1.409);
IMinMaxRange ran = new MinMaxRange(1, 2);
ran.Max = 1;
IBDASpecData[] uvSpecData = nonMsReader.GetUVSpectrum(device, range);
if (uvSpecData == null)
{
println("No UV signal found");
}
else
{
foreach (IBDASpecData uvSpec in uvSpecData)
{
if (uvSpec.TotalDataPoints != 0)
{
int dataPopints = uvSpec.TotalDataPoints;
double[] xArrayUV = uvSpec.XArray;
float[] yArrayUV = uvSpec.YArray;
// Expoting this information to a file on disk
FileStream fileUV = new FileStream(@"C:\temp\reportUV.csv", FileMode.Create, FileAccess.ReadWrite);
TextWriter swUV = new StreamWriter(fileUV);
swUV.WriteLine("#Point,X(Nanometers),Y(mAU)");
for (int i = 0; i < xArrayUV.Length; i++)
{
swUV.WriteLine(i.ToString() + "," + xArrayUV[i].ToString() + "," + yArrayUV[i].ToString());
}
swUV.Close();
fileUV.Close();
}
else
{
println("No UV signal found");
}
}
}
}
#endregion
#region InstrumentCurves - TCC
if (device.DeviceType == DeviceType.ThermostattedColumnCompartment)
{
ISignalInfo[] sigInfo = nonMsReader.GetSignalInfo(device, StoredDataType.InstrumentCurves);
if (sigInfo.Length == 0)
{
println("No TCC Curves found");
}
else
{
IBDAChromData chromData = nonMsReader.GetSignal(sigInfo[0]);
if ((chromData == null) || (chromData.TotalDataPoints == 0))
{
println("No TCC Curves found");
}
else
{
int count = chromData.TotalDataPoints;
double[] xArray = chromData.XArray;
float[] yArray = chromData.YArray;
// Expoting this information to a file on disk
FileStream file = new FileStream(@"C:\temp\reportInstrumentCurve.csv", FileMode.Create, FileAccess.ReadWrite);
TextWriter sw = new StreamWriter(file);
sw.WriteLine("#Point,X(Minutes),Y(Response Units)");
for (int i = 0; i < xArray.Length; i++)
{
sw.WriteLine(i.ToString() + "," + xArray[i].ToString() + "," + yArray[i].ToString());
}
sw.Close();
file.Close();
}
}
}
#endregion
}
}
}
public Heightmap(HeightmapParams vars)
{
worldData = GameObject.Find("World").GetComponent<WorldData>();
form = vars.form;
formArg = vars.formArg;
mapSize = worldData.GetWorldSize();
featureSizePower = vars.featureSizePower;
heightScale = vars.heightScale;
heightStepped = vars.heightStepped;
heightStep = Mathf.Max(vars.heightStep, 0.00001f);
floatMap = new float[mapSize*mapSize];
featureSize = (int)Mathf.Pow(2.0f, (float)featureSizePower);
diamondSquared = vars.diamondSquared;
diamondRange = vars.diamondRange;
squareRange = vars.squareRange;
}
