/// <summary>
/// Combine damage amounts dictionary
/// </summary>
/// <param name="sourceDictionary"></param>
/// <param name="newEntry"></param>
/// <returns></returns>
public static Dictionary <DamageElement, MinMaxFloat> CombineDamages(Dictionary <DamageElement, MinMaxFloat> sourceDictionary, KeyValuePair <DamageElement, MinMaxFloat> newEntry)
{
if (sourceDictionary == null)
{
sourceDictionary = new Dictionary <DamageElement, MinMaxFloat>();
}
GameInstance gameInstance = GameInstance.Singleton;
DamageElement damageElement = newEntry.Key;
if (damageElement == null)
{
damageElement = gameInstance.DefaultDamageElement;
}
MinMaxFloat value = newEntry.Value;
if (!sourceDictionary.ContainsKey(damageElement))
{
sourceDictionary[damageElement] = value;
}
else
{
sourceDictionary[damageElement] += value;
}
return(sourceDictionary);
}
/// <summary>
/// Make damage - amount key-value pair which calculates with damage inflictions
/// </summary>
/// <param name="source"></param>
/// <param name="level"></param>
/// <param name="rate"></param>
/// <param name="effectiveness"></param>
/// <param name="damageInflictions"></param>
/// <returns></returns>
public static Dictionary <DamageElement, MinMaxFloat> MakeDamageWithInflictions(DamageIncremental source, short level, float rate, float effectiveness, Dictionary <DamageElement, float> damageInflictions)
{
Dictionary <DamageElement, MinMaxFloat> result = new Dictionary <DamageElement, MinMaxFloat>();
GameInstance gameInstance = GameInstance.Singleton;
MinMaxFloat baseDamage = (source.amount.GetAmount(level) * rate) + effectiveness;
if (damageInflictions != null && damageInflictions.Count > 0)
{
foreach (KeyValuePair <DamageElement, float> damageInflictionAmount in damageInflictions)
{
DamageElement damageElement = damageInflictionAmount.Key;
result = CombineDamages(result, new KeyValuePair <DamageElement, MinMaxFloat>(damageElement, baseDamage * damageInflictionAmount.Value));
}
}
else
{
DamageElement damageElement = source.damageElement;
if (damageElement == null)
{
damageElement = gameInstance.DefaultDamageElement;
}
result = CombineDamages(result, new KeyValuePair <DamageElement, MinMaxFloat>(damageElement, baseDamage));
}
return(result);
}
private float EvaluateCurve(AnimationCurve curve, MinMaxFloat minMaxContainer)
{
float num = UnityEngine.Random.Range(0f - AIController.instance.settings.curveVarianceMax, AIController.instance.settings.curveVarianceMax) * (minMaxContainer.max - minMaxContainer.min);
float num2 = Mathf.Lerp(minMaxContainer.max, minMaxContainer.min, curve.Evaluate(DifficultyFactor));
return(minMaxContainer.ClampInside(num2 + num));
}
public override void ReceiveDamage(IAttackerEntity attacker, CharacterItem weapon, Dictionary <DamageElement, MinMaxFloat> allDamageAmounts, CharacterBuff debuff, uint hitEffectsId)
{
if (!IsServer || IsDead())
{
return;
}
base.ReceiveDamage(attacker, weapon, allDamageAmounts, debuff, hitEffectsId);
float calculatingTotalDamage = 0f;
if (allDamageAmounts.Count > 0)
{
foreach (KeyValuePair <DamageElement, MinMaxFloat> allDamageAmount in allDamageAmounts)
{
DamageElement damageElement = allDamageAmount.Key;
MinMaxFloat damageAmount = allDamageAmount.Value;
calculatingTotalDamage += damageAmount.Random();
}
}
// Apply damages
int totalDamage = (int)calculatingTotalDamage;
CurrentHp -= totalDamage;
ReceivedDamage(attacker, CombatAmountType.NormalDamage, totalDamage);
// If current hp <= 0, character dead
if (IsDead())
{
NetworkDestroy();
}
}
public static MinMaxFloat operator -(MinMaxFloat a, float amount)
{
var result = new MinMaxFloat();
result.min = a.min - amount;
result.max = a.max - amount;
return(result);
}
public static MinMaxFloat operator *(MinMaxFloat a, float multiplier)
{
var result = new MinMaxFloat();
result.min = a.min * multiplier;
result.max = a.max * multiplier;
return(result);
}
public static MinMaxFloat operator /(MinMaxFloat a, float divider)
{
var result = new MinMaxFloat();
result.min = a.min / divider;
result.max = a.max / divider;
return(result);
}
public static MinMaxFloat operator +(MinMaxFloat a, MinMaxFloat b)
{
var result = new MinMaxFloat();
result.min = a.min + b.min;
result.max = a.max + b.max;
return(result);
}
public static MinMaxFloat operator +(MinMaxFloat a, float amount)
{
MinMaxFloat result = new MinMaxFloat();
result.min = a.min + amount;
result.max = a.max + amount;
return(result);
}
public static MinMaxFloat operator -(MinMaxFloat a, MinMaxFloat b)
{
MinMaxFloat result = new MinMaxFloat();
result.min = a.min - b.min;
result.max = a.max - b.max;
return(result);
}
protected void TestImplicitCast()
{
MinMaxInt minMaxInt = prefsMinMaxInt;
MinMaxFloat minMaxFloat = prefsMinMaxFloat;
MinMaxVector2 minMaxVector2 = prefsMinMaxVector2;
MinMaxVector3 minMaxVector3 = prefsMinMaxVector3;
MinMaxVector4 minMaxVector4 = prefsMinMaxVector4;
MinMaxVector2Int minMaxVector2Int = prefsMinMaxVector2Int;
MinMaxVector3Int minMaxVector3Int = prefsMinMaxVector3Int;
}
protected override void UpdateData()
{
if (uiTextAmount != null)
{
DamageElement element = Data.damageElement;
MinMaxFloat amount = Data.amount;
uiTextAmount.text = string.Format(
LanguageManager.GetText(formatKeyAmount),
element.Title,
amount.min.ToString("N0"),
amount.max.ToString("N0"));
}
}
public TreeGenerationProperties(MinMaxInt entitiesCount, MinMaxFloat distance, MinMaxFloat size,
int maxTreeLevel)
{
if (maxTreeLevel == 0)
{
maxTreeLevel++;
}
EntitiesCount = entitiesCount;
Distance = distance;
MaxTreeLevel = maxTreeLevel;
Size = size;
}
protected override void UpdateData()
{
if (Data == null || Data.Count == 0)
{
if (textAllInfliction != null)
{
textAllInfliction.gameObject.SetActive(false);
}
foreach (var textAmount in CacheTextInflictions)
{
var element = textAmount.Key;
var format = element == GameInstance.Singleton.DefaultDamageElement ? defaultElementInflictionFormat : inflictionFormat;
textAmount.Value.text = string.Format(format, element.title, "0");
}
}
else
{
var text = "";
var sumDamage = new MinMaxFloat();
foreach (var dataEntry in Data)
{
if (dataEntry.Key == null || dataEntry.Value == 0)
{
continue;
}
var element = dataEntry.Key;
var rate = dataEntry.Value;
if (!string.IsNullOrEmpty(text))
{
text += "\n";
}
var format = element == GameInstance.Singleton.DefaultDamageElement ? defaultElementInflictionFormat : inflictionFormat;
var amountText = string.Format(format, element.title, (rate * 100f).ToString("N0"));
text += amountText;
Text textDamages;
if (CacheTextInflictions.TryGetValue(dataEntry.Key, out textDamages))
{
textDamages.text = amountText;
}
sumDamage += rate;
}
if (textAllInfliction != null)
{
textAllInfliction.gameObject.SetActive(!string.IsNullOrEmpty(text));
textAllInfliction.text = text;
}
}
}
protected new void Start()
{
base.Start();
inGarage = (base.gameObject.layer == LayerMask.NameToLayer("GarageTank") || !TankGame.instance);
if (!inGarage)
{
animator.SetFloat("Speed", 0f);
base.Rigidbody.position = new Vector2(base.Rigidbody.position.x, TankGame.instance.GetGroundHeight(base.Rigidbody.position.x) + centerOffset.y);
moveBoundaries = new MinMaxFloat(TankGame.instance.backBlockerContainer.position.x, PlayerDataManager.IsSelectedGameModePvP ? TankGame.instance.frontBlockerContainer.position.x : float.PositiveInfinity);
activeCollisions = new Dictionary <TankContainer, float>();
FixedUpdate();
chassis.rotation = Quaternion.Euler(0f, chassis.rotation.eulerAngles.y, chassisRotationTarget);
StartCoroutine(ChassisRotationRoutine());
}
}
public static MinMaxFloat GetSumDamages(Dictionary <DamageElement, MinMaxFloat> damages)
{
var damageAmount = new MinMaxFloat();
damageAmount.min = 0;
damageAmount.max = 0;
if (damages == null || damages.Count == 0)
{
return(damageAmount);
}
foreach (var damage in damages)
{
damageAmount += damage.Value;
}
return(damageAmount);
}
public static Vector3 RandomPointOnCircle(MinMaxFloat distanceFromCenter)
{
int maximumTries = 10;
for (int i = 0; i < maximumTries; i++)
{
Vector2 point = Random.insideUnitCircle * distanceFromCenter.max;
if (point.magnitude > distanceFromCenter.min)
{
return(new Vector3(point.x, 0.0f, point.y));
}
}
return(Vector3.zero);
}
public override void GetAttackingData(
ref bool isLeftHand,
out AnimActionType animActionType,
out int dataId,
out int animationIndex,
out CharacterItem weapon,
out float triggerDuration,
out float totalDuration,
out DamageInfo damageInfo,
out Dictionary <DamageElement, MinMaxFloat> allDamageAmounts)
{
// Initialize data
isLeftHand = false;
animActionType = AnimActionType.AttackRightHand;
// Monster will not have weapon type so set dataId to `0`, then random attack animation from default attack animtions
dataId = 0;
// Monster will not have weapon data
weapon = null;
// Random attack animation
CharacterModel.GetRandomRightHandAttackAnimation(dataId, out animationIndex, out triggerDuration, out totalDuration);
// Assign damage data
damageInfo = monsterCharacter.damageInfo;
// Assign damage amounts
allDamageAmounts = new Dictionary <DamageElement, MinMaxFloat>();
DamageElement damageElement = monsterCharacter.damageAmount.damageElement;
MinMaxFloat damageAmount = monsterCharacter.damageAmount.amount.GetAmount(Level);
if (damageElement == null)
{
damageElement = gameInstance.DefaultDamageElement;
}
allDamageAmounts.Add(damageElement, damageAmount);
}
void Start()
{
if (!_audioSource)
{
_audioSource = GetComponent <AudioSource>();
}
if (_audioClip)
{
_audioSource.clip = _audioClip;
}
//Warn if settings results in a clip that will want to play more often than the clip length allows for
MinMaxFloat clipLenght = new MinMaxFloat(CalculateClipLength(_rangeOfPitch.Min), CalculateClipLength(_rangeOfPitch.Max));
MinMaxFloat clipDelay = new MinMaxFloat(BPMToDelay(_rangeOfBPM.Min), BPMToDelay(_rangeOfBPM.Max));
if (clipDelay.Min < clipLenght.Min)
{
Debug.LogWarning("Shortest clip length is longer than the shortest delay! Shortest Clip Length: " + clipLenght.Min + " Shortest Delay: " + clipDelay.Min);
}
if (clipDelay.Max < clipLenght.Max)
{
Debug.LogWarning("Longest clip length is longer than the longest delay! Longest Clip Length: " + clipLenght.Min + " Longest Delay: " + clipDelay.Min);
}
}
protected override void UpdateData()
{
cacheStats = showStatsWithBuffs ? Data.GetStats() : Data.GetStats(true, false);
cacheAttributes = showAttributeWithBuffs ? Data.GetAttributes() : Data.GetAttributes(true, false);
cacheResistances = showResistanceWithBuffs ? Data.GetResistances() : Data.GetResistances(true, false);
cacheIncreaseDamages = showDamageWithBuffs ? Data.GetIncreaseDamages() : Data.GetIncreaseDamages(true, false);
cacheWeightLimit = cacheStats.weightLimit;
if (!showStatsWithBuffs)
{
// Always increase weight limit by buff bonus because it should always show real weight limit in UIs
cacheWeightLimit += Data.GetBuffStats().weightLimit;
}
if (bonusAttributes == null)
{
bonusAttributes = new Dictionary <Attribute, short>();
}
if (bonusResistances == null)
{
bonusResistances = new Dictionary <DamageElement, float>();
}
if (bonusIncreaseDamages == null)
{
bonusIncreaseDamages = new Dictionary <DamageElement, MinMaxFloat>();
}
if (bonusSkills == null)
{
bonusSkills = new Dictionary <Skill, short>();
}
if (cacheEquipmentSets == null)
{
cacheEquipmentSets = new Dictionary <EquipmentSet, int>();
}
Data.GetEquipmentSetBonus(out bonusStats, bonusAttributes, bonusResistances, bonusIncreaseDamages, bonusSkills, cacheEquipmentSets);
// Increase stats by equipment set bonus
cacheStats += bonusStats;
cacheAttributes = GameDataHelpers.CombineAttributes(cacheAttributes, bonusAttributes);
cacheResistances = GameDataHelpers.CombineResistances(cacheResistances, bonusResistances);
cacheIncreaseDamages = GameDataHelpers.CombineDamages(cacheIncreaseDamages, bonusIncreaseDamages);
cacheWeightLimit += bonusStats.weightLimit;
if (uiTextWeightLimit != null)
{
uiTextWeightLimit.text = string.Format(
LanguageManager.GetText(formatKeyWeightLimitStats),
GameInstance.Singleton.GameplayRule.GetTotalWeight(Data).ToString("N2"),
cacheWeightLimit.ToString("N2"));
}
CharacterItem rightHandItem = Data.EquipWeapons.rightHand;
CharacterItem leftHandItem = Data.EquipWeapons.leftHand;
Item rightHandWeapon = rightHandItem.GetWeaponItem();
Item leftHandWeapon = leftHandItem.GetWeaponItem();
Dictionary <DamageElement, MinMaxFloat> rightHandDamages = rightHandWeapon != null?GameDataHelpers.CombineDamages(cacheIncreaseDamages, rightHandWeapon.GetDamageAmount(rightHandItem.level, rightHandItem.GetEquipmentBonusRate(), Data)) : null;
Dictionary <DamageElement, MinMaxFloat> leftHandDamages = leftHandWeapon != null?GameDataHelpers.CombineDamages(cacheIncreaseDamages, leftHandWeapon.GetDamageAmount(leftHandItem.level, leftHandItem.GetEquipmentBonusRate(), Data)) : null;
if (uiTextWeaponDamages != null)
{
string textDamages = "";
if (rightHandWeapon != null)
{
MinMaxFloat sumDamages = GameDataHelpers.GetSumDamages(rightHandDamages);
if (!string.IsNullOrEmpty(textDamages))
{
textDamages += "\n";
}
textDamages += string.Format(
LanguageManager.GetText(formatKeyWeaponDamage),
sumDamages.min.ToString("N0"),
sumDamages.max.ToString("N0"));
}
if (leftHandWeapon != null)
{
MinMaxFloat sumDamages = GameDataHelpers.GetSumDamages(leftHandDamages);
if (!string.IsNullOrEmpty(textDamages))
{
textDamages += "\n";
}
textDamages += string.Format(
LanguageManager.GetText(formatKeyWeaponDamage),
sumDamages.min.ToString("N0"),
sumDamages.max.ToString("N0"));
}
if (rightHandWeapon == null && leftHandWeapon == null)
{
Item defaultWeaponItem = GameInstance.Singleton.DefaultWeaponItem;
WeaponItemEquipType defaultWeaponItemType = defaultWeaponItem.EquipType;
KeyValuePair <DamageElement, MinMaxFloat> damageAmount = defaultWeaponItem.GetDamageAmount(1, 1f, Data);
textDamages = string.Format(
LanguageManager.GetText(formatKeyWeaponDamage),
damageAmount.Value.min.ToString("N0"),
damageAmount.Value.max.ToString("N0"));
}
uiTextWeaponDamages.text = textDamages;
}
if (uiRightHandDamages != null)
{
if (rightHandWeapon == null)
{
uiRightHandDamages.Hide();
}
else
{
uiRightHandDamages.Show();
uiRightHandDamages.Data = rightHandDamages;
}
}
if (uiLeftHandDamages != null)
{
if (leftHandWeapon == null)
{
uiLeftHandDamages.Hide();
}
else
{
uiLeftHandDamages.Show();
uiLeftHandDamages.Data = leftHandDamages;
}
}
if (uiCharacterStats != null)
{
uiCharacterStats.Data = cacheStats;
}
if (uiCharacterResistances != null)
{
uiCharacterResistances.Data = cacheResistances;
}
if (CacheUICharacterAttributes.Count > 0 && Data != null)
{
CharacterAttribute tempCharacterAttribute;
Attribute tempAttribute;
short tempAmount;
IList <CharacterAttribute> characterAttributes = Data.Attributes;
for (int indexOfData = 0; indexOfData < characterAttributes.Count; ++indexOfData)
{
tempCharacterAttribute = characterAttributes[indexOfData];
tempAttribute = tempCharacterAttribute.GetAttribute();
UICharacterAttribute cacheUICharacterAttribute;
tempAmount = 0;
if (CacheUICharacterAttributes.TryGetValue(tempAttribute, out cacheUICharacterAttribute))
{
if (cacheAttributes.ContainsKey(tempAttribute))
{
tempAmount = cacheAttributes[tempAttribute];
}
cacheUICharacterAttribute.Setup(new CharacterAttributeTuple(tempCharacterAttribute, tempAmount), Data, indexOfData);
cacheUICharacterAttribute.Show();
}
}
}
if (uiCharacterBuffs != null)
{
uiCharacterBuffs.UpdateData(Data);
}
}
/// <summary>
/// Add another MinMax variable's values to this one
/// </summary>
/// <param name="newMinMax"></param>
public virtual void Remove(MinMaxFloat newMinMax)
{
max += newMinMax.max;
value += newMinMax.value;
}
public static ChunkData GenerateChunkData(Vector2 startPoint, Vector2 chunkCoord, WorldSettings worldSettings)
{
int width = worldSettings.meshSettings.numVertsPerLine;
int height = worldSettings.meshSettings.numVertsPerLine;
int extraBorderSize;
Region biomeMap = GetBiomeMap(chunkCoord, worldSettings, out extraBorderSize);
Region worldHeightMap = worldSettings.globalHeightMapSettings == null ? new Region(new float[width, height], 0, 0) : RegionGenerator.GenerateRegion(width, height, worldSettings.globalHeightMapSettings, startPoint);
float[,] combinedHeightMap = new float[width, height];
List <int> activeBiomes = new List <int>();
MinMaxFloat minMax = new MinMaxFloat();
Material material = null;
float worldEdgeSmoothing = worldSettings.globalBiomeSettings.heightMapEdgeSmoothing;
// Add global world height
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
combinedHeightMap[x, y] += worldHeightMap.values[x, y];
}
}
//string debug = "";
// Add biome height
foreach (BiomeSettings biome in worldSettings.biomes)
{
// @TODO: apply masking to materials/texturing, too (one material/shader for entire world?)
if (material == null)
{
material = biome.TerrainMaterial;
}
Region heightMap = RegionGenerator.GenerateRegion(width, height, biome.heightSettings, startPoint);
/*
* if (Mathf.Approximately(biome.worldMapBiomeValue, 0f) && startPoint.x >= -150 && startPoint.x <= -50 && startPoint.y >= -150 && startPoint.y <= -50)
* {
* debug = "chunkPosition" + startPoint + " ";
* }
*/
float[,] biomeBlurMask = CalculateBlurredBiomeMask(biomeMap.values, width, height, biome.worldMapBiomeValue, worldEdgeSmoothing * biome.heightMapEdgeSmoothingModifier);//, debug);
minMax.AddValue(heightMap.minValue + worldHeightMap.minValue);
minMax.AddValue(heightMap.maxValue + worldHeightMap.maxValue);
for (int y = 0; y < height; y++)
{
for (int x = 0; x < width; x++)
{
float biomeBlurValue = biomeBlurMask[x, y];
if (biomeBlurValue <= 0)
{
continue;
}
activeBiomes.Add(biome.id);
combinedHeightMap[x, y] += heightMap.values[x, y] * biomeBlurValue;
}
}
}
return(new ChunkData
{
heightMap = new Region(combinedHeightMap, minMax.Min, minMax.Max),
material = material
});
}
public bool GetCueInfo(out float duration, out int repeats)
{
duration = GetDuration();
repeats = repeat.forever ? -1 : repeat.count;
return(duration > Mathf.Epsilon);
}
public DamageElementAmountTuple(DamageElement damageElement, MinMaxFloat amount)
{
this.damageElement = damageElement;
this.amount = amount;
}
public static bool CheckAllowedSlope(MinMaxFloat allowedAngles, Vector2 surfaceNormal)
{
float angle = Mathf.Atan2(surfaceNormal.y, surfaceNormal.x) * Mathf.Rad2Deg - 90f;
return(angle >= allowedAngles.Min && angle <= allowedAngles.Max);
}
public virtual void MatchValues(MinMaxFloat newMinMax)
{
min = (int)newMinMax.min;
max = (int)newMinMax.max;
value = (int)newMinMax.value;
}
public DamageStat(DamageType type, MinMaxInt damage, MinMaxFloat modifier) : this(type, damage)
{
this.modifier = modifier;
}
