private List <Weapon> GetBonus(List <Weapon> weapons, Fighter t)
{
Weapon e = t.Weapon;
if (e == null)
{
return(weapons);
}
List <Weapon> bonus = new List <Weapon>();
foreach (Weapon w in weapons)
{
if (StatsCalc.TriangleBonus(w, e) > 1 || StatsCalc.WeaponEffectiveness(w, Target) > 1)
{
bonus.Add(w);
}
}
if (bonus.Count == 0)
{
return(weapons);
}
return(bonus);
}
public void MeanTest()
{
StatsCalc sc = new StatsCalc();
decimal[] dataPoints = { 1M, 2M, 3M };
Assert.AreEqual(2, sc.Mean(dataPoints));
}
private IEnumerator _LevelUp()
{
Unit.Exp = 0;
Unit.stats.level++;
Unit.ExpToNextLevel = StatsCalc.ExperienceToNextLevel(Unit.stats.level);
yield return(new WaitForSeconds(1f));
}
public void MeanTest()
{
decimal[] DataPoints = { 1M, 2M };
StatsCalc statsCalc = new StatsCalc();
var result = statsCalc.Mean(DataPoints);
Assert.AreEqual(1.5M, result);
}
public void LoadMonsterToken(MonsterSaveToken m)
{
MonsterStatsSet();
StatsCalc stats = new StatsCalc(gameObject.GetComponent <Monster>());
GetStats(stats);
}
public void UseItem()
{
SaveMonsterToken();
StatsCalc stats = new StatsCalc(gameObject.GetComponent <Monster>());
GetStats(stats);
}
public IEnumerable <MovieStats> GetStats()
{
var stats = new StatsCalc()
.CalcStats()
.OrderByDescending(r => r.AverageWatchDurationS)
.ThenByDescending(r => r.ReleaseYear);
return(stats);
}
//use this to get a monster's potential stats without saving them
public void CheckStats(MonsterSaveToken m)
{
MonsterStatsSet();
StatsCalc stats = new StatsCalc(gameObject.GetComponent <Monster>());
info = stats.Monster.info;
tempStats = stats.Monster.tempStats;
}
public static void Attack(Fighter attacker, Fighter target, bool doAnimations)
{
IsBattling = true;
int spd1 = StatsCalc.AttackSpeed(attacker.Unit.stats.speed, attacker.Weapon.weight, attacker.Unit.stats.constitution);
int spd2 = StatsCalc.AttackSpeed(target.Unit.stats.speed, target.Weapon.weight, target.Unit.stats.constitution);
bool repeated = StatsCalc.RepeatedAttack(spd1, spd2);
bool repeatedCounter = StatsCalc.RepeatedAttack(spd2, spd1);
bool counter = false;
Cell[] counterArea = Map.GetExtendedArea(new Cell[1] {
Map.UnitTile(target)
}, target.Weapon.range, target.Weapon.rangedClosedSet, target.Weapon.closedSetMin);
foreach (Cell c in counterArea)
{
if (c == Map.UnitTile(attacker))
{
counter = true;
break;
}
}
Offensive atk1 = new Offensive(attacker, target);
Offensive cnt1 = null;
Offensive atk2 = null;
Offensive cnt2 = null;
if (counter)
{
cnt1 = new Offensive(target, attacker)
{
IsCounter = true
};
}
if (repeated)
{
atk2 = new Offensive(attacker, target, true);
}
if (repeatedCounter)
{
cnt2 = new Offensive(target, attacker, true);
cnt1.IsCounter = true;
}
instance.StartCoroutine(DoAttacks(
new Offensive[4]
{
atk1,
cnt1,
atk2,
cnt2
}
));
}
public void OnLevelUp()
{
info.level += 1;
saveToken.level = info.level;
SetExp();
StatsCalc stats = new StatsCalc(gameObject.GetComponent <Monster>());
GetStats(stats);
GameManager.Instance.GetComponent <YourMonsters>().yourMonstersDict.Remove(info.index);
GameManager.Instance.GetComponent <YourMonsters>().yourMonstersDict.Add(info.index, PlayerPrefs.GetString(info.index.ToString()));
GameManager.Instance.SendNotificationToPlayer(info.species, info.level, NotificationType.LevelUp, "none");
}
//Day node_id route_id carrier_acct_id Total Completed InMinutes OutMinutes Cost Name PopName
public RouteReportRecord(int?pDay, string pNode, string pCustomerName, int?pTotal, int?pCompleted, int?pInMinutes, decimal?pOutMinutes, decimal?pCost, string pRouteName, string pCarrierName)
{
Date = TimokDate.ToDateTime((int)pDay).ToShortDateString();
Node = pNode;
CustomerName = pCustomerName;
Total = pTotal;
Completed = pCompleted;
InMinutes = pInMinutes;
OutMinutes = pOutMinutes;
Cost = pCost;
RouteName = pRouteName;
CarrierName = pCarrierName;
Asr = StatsCalc.GetASR(Total, Completed);
Acd = StatsCalc.GetACD(OutMinutes, Completed);
}
void SetBaseStats(Fighter f)
{
Weapon w = f.Weapon;
bool magic = false;
if (w != null)
{
magic = w.type == Weapon.WeaponType.Anima_Tome || w.type == Weapon.WeaponType.Dark_Tome || w.type == Weapon.WeaponType.Light_Tome;
}
int str = 0;
float evade = 0;
float crit = 0;
float acc = 0;
if (w != null)
{
if (!magic)
{
str = StatsCalc.PhysicalAttack(f.Unit.stats.strength, w.might, 1, 1, StatsCalc.SupportBonus(f), false);
}
else
{
str = StatsCalc.MagicalAttack(f.Unit.stats.magic, w.might, 1, 1, StatsCalc.SupportBonus(f));
}
evade = StatsCalc.Avoid(f.Unit.stats.speed, f.Unit.stats.luck, new Cell.TerrainBonus(), StatsCalc.SupportBonus(f));
crit = StatsCalc.CriticalChance(StatsCalc.CriticalRate(w.crit, f.Unit.stats.skill, StatsCalc.SupportBonus(f), StatsCalc.ClassCrit(f.Unit.unitClass)), 0);
acc = StatsCalc.Accuracy(StatsCalc.HitRate(w.hit, f.Unit.stats.skill, f.Unit.stats.luck, StatsCalc.SupportBonus(f)), StatsCalc.Avoid(f.Unit.stats.speed, f.Unit.stats.luck, new Cell.TerrainBonus(), StatsCalc.SupportBonus(f)), 1);
}
baseAtk = str;
baseAcc = acc;
baseCrt = crit;
baseEva = evade;
}
public Offensive(Fighter attacker, Fighter defender, bool repeated = false)
{
Attacker = attacker;
Defender = defender;
Seed = StatsCalc.Seed(new Vector2Int[2] {
attacker.Position(), defender.Position()
});
Rand = new System.Random(Seed);
IsPhysical = Attacker.Weapon.isPhysical;
AtkStat = IsPhysical ? Attacker.Unit.stats.strength : Attacker.Unit.stats.magic;
DefStat = IsPhysical ? Defender.Unit.stats.defense : Defender.Unit.stats.resistance;
Cell = Map.UnitTile(Attacker);
Support1 = StatsCalc.SupportBonus(Attacker);
Support2 = StatsCalc.SupportBonus(Defender);
TriangleBonus = StatsCalc.TriangleBonus(Attacker, Defender);
TerrainBonus1 = StatsCalc.TerrainBonus(Map.UnitTile(Attacker));
TerrainBonus2 = StatsCalc.TerrainBonus(Map.UnitTile(Defender));
Speed1 = Attacker.Unit.stats.speed;
Speed2 = Defender.Unit.stats.speed;
Wgt1 = Attacker.Weapon.weight;
Wgt2 = Defender.Weapon.weight;
Con1 = Attacker.Unit.stats.constitution;
Con2 = Defender.Unit.stats.constitution;
Attack = AtkStat;
Defense = DefStat;
Spd1 = StatsCalc.AttackSpeed(Speed1, Wgt1, Con1);
Spd2 = StatsCalc.AttackSpeed(Speed2, Wgt2, Con2);
Atk = StatsCalc.PhysicalAttack(Attack, Attacker.Weapon.might, TriangleBonus, StatsCalc.WeaponEffectiveness(Attacker.Weapon, Defender), Support1, false);
Def = StatsCalc.PhysicalDefense(TerrainBonus2, Defense, Support2);
HitRate = StatsCalc.HitRate(Attacker.Weapon.hit, Attacker.Unit.stats.skill, Attacker.Unit.stats.luck, Support1);
Avoid = StatsCalc.Avoid(Speed2, Defender.Unit.stats.luck, TerrainBonus2, Support2);
Acc = StatsCalc.Accuracy(HitRate, Avoid, TriangleBonus);
CritRate = StatsCalc.CriticalRate(Attacker.Weapon.crit, Attacker.Unit.stats.skill, Support1, StatsCalc.ClassCrit(Attacker.Unit.unitClass));
CritEvade = StatsCalc.CriticalEvade(Defender.Unit.stats.luck, Support2);
CritChance = StatsCalc.CriticalChance(CritRate, CritEvade);
if (StatsCalc.ClassCriticalModifier.ContainsKey(Attacker.Unit.unitClass))
{
CritChance += StatsCalc.ClassCriticalModifier[Attacker.Unit.unitClass];
}
if (repeated)
{
CritChance += Attacker.Unit.stats.pursuitCriticalCoefficient;
}
Hit = Rand.Next(0, 100) <= Acc;
Crit = Rand.Next(0, 100) <= CritChance;
Damage = Crit ? StatsCalc.CriticalDamage(StatsCalc.Damage(Atk, Def)) : StatsCalc.Damage(Atk, Def);
if (Attacker.LastTarget == Defender)
{
Attacker.RepeatedTarget++;
}
else
{
Attacker.LastTarget = Defender;
Attacker.RepeatedTarget = 0;
}
}
private static IEnumerator _Attack(Offensive offensive)
{
if (offensive.Attacker.Weapon.uses <= 0)
{
yield break;
}
if (GameSettings.DoBattleAnimation)
{
yield return(BattleAnimController.WaitForBattleAnimation(offensive));
}
if (offensive.Hit)
{
offensive.Defender.Damage(offensive.Damage);
Debug.Log(offensive.Attacker.Unit.name + " attacked " + offensive.Defender.Unit.name + " for " + offensive.Damage + " damage \n" +
offensive.Defender.Unit.name + " hp: " + offensive.Defender.CurrentHP + "/" + offensive.Defender.Unit.stats.hp);
}
else
{
Debug.Log(offensive.Attacker.Unit.name + " missed " + offensive.Defender.Unit.name);
}
if (!offensive.Attacker.Weapon.unbreakable)
{
offensive.Attacker.Weapon.uses--;
}
if (offensive.Defender == offensive.Attacker.LastTarget && offensive.Attacker.LastTarget != null)
{
offensive.Attacker.RepeatedTarget++;
}
else
{
offensive.Attacker.LastTarget = offensive.Defender;
offensive.Attacker.RepeatedTarget = 1;
}
if (offensive.Attacker.CurrentHP <= 0)
{
UnitManager.Kill(offensive.Attacker);
}
if (offensive.Defender.CurrentHP <= 0)
{
UnitManager.Kill(offensive.Defender);
}
offensive.Attacker.AddEXP(
StatsCalc.EXPGain_Damage(
offensive.Attacker.Unit.stats.level,
offensive.Defender.Unit.stats.level,
offensive.Attacker.RepeatedTarget,
offensive.Defender == null || offensive.Defender.CurrentHP <= 0,
false
)
);
while (GameSettings.DoBattleAnimation && BattleAnimController.IsAnimating)
{
yield return(null);
}
yield return(new WaitForSeconds(0.5f));
}
public void OnGUI()
{
target = this;
serializedObject = new SerializedObject(target);
Init();
float width = EditorGUIUtility.currentViewWidth;
scrollPos = EditorGUILayout.BeginScrollView(scrollPos, false, false);
serializedObject.Update();
GUIStyle label = new GUIStyle(GUI.skin.label)
{
fontSize = 30,
fontStyle = FontStyle.Bold,
alignment = TextAnchor.UpperCenter
};
EditorGUI.HelpBox(new Rect(10, 5, width - 25, 40), "", MessageType.None);
EditorGUI.LabelField(new Rect(0, 5, width, 30), name, label);
GUILayout.Space(88);
if (unitFile != null)
{
overrideFile = EditorGUI.Toggle(new Rect(width - 17, 70, 16, 16), new GUIContent(""), overrideFile);
EditorGUI.LabelField(new Rect(width - 103, 70, 100, 16), new GUIContent("Override File?"));
}
EditorGUI.PropertyField(new Rect(14, 50, width * 2 / 3, 16), nameProperty, new GUIContent("Name"));
EditorGUI.PropertyField(new Rect(14 + width * 3.7f / 5, 50, width / 4.5f, 16), unitFileProperty, new GUIContent(""));
EditorGUI.LabelField(new Rect(18 + width * 2 / 3, 50, width * 2 / 3, 16), "File");
EditorGUILayout.PropertyField(classProperty, new GUIContent("Class"));
EditorGUILayout.PropertyField(sexProperty, new GUIContent("Sex"));
EditorGUILayout.PropertyField(alignmentProperty, new GUIContent("Alignment"));
EditorGUILayout.PropertyField(useableWeaponsProperty, new GUIContent("Useable Weapon Types"));
EditorGUILayout.PropertyField(affinityProperty, new GUIContent("Affinity"));
displayStats = EditorGUILayout.Foldout(displayStats, "Stats");
if (displayStats)
{
int boxHeight = 172;
{
EditorGUI.indentLevel++;
Rect position = GUILayoutUtility.GetLastRect();
position.x += 4;
position.y += 5;
EditorGUI.HelpBox(new Rect(position.x + 8, position.y + 11, width - 31, boxHeight), "", MessageType.None);
float i = 1;
EditorGUILayout.BeginVertical();
EditorGUILayout.BeginHorizontal();
Exp = EditorGUI.IntSlider(new Rect(position.x, position.y + 16 * i, width - 30, 16), new GUIContent("EXP"), Exp, 0, StatsCalc.ExperienceToNextLevel(stats.level + 1));
EditorGUILayout.EndHorizontal();
i++;
EditorGUILayout.BeginHorizontal();
EditorGUI.PropertyField(new Rect(position.x, position.y + 16 * i, width / 2f - 30, 16), levelProperty);
EditorGUI.PropertyField(new Rect(position.x + width / 2f, position.y + 16 * i, width / 2f - 30, 16), hpProperty);
EditorGUILayout.EndHorizontal();
i++;
EditorGUILayout.BeginHorizontal();
EditorGUI.PropertyField(new Rect(position.x, position.y + 16 * i, width / 2f - 30, 16), strengthProperty);
EditorGUI.PropertyField(new Rect(position.x + width / 2f, position.y + 16 * i, width / 2f - 30, 16), magicProperty);
EditorGUILayout.EndHorizontal();
i++;
EditorGUILayout.BeginHorizontal();
EditorGUI.PropertyField(new Rect(position.x, position.y + 16 * i, width / 2f - 30, 16), skillProperty);
EditorGUI.PropertyField(new Rect(position.x + width / 2f, position.y + 16 * i, width / 2f - 30, 16), speedProperty);
EditorGUILayout.EndHorizontal();
i++;
EditorGUILayout.BeginHorizontal();
EditorGUI.PropertyField(new Rect(position.x, position.y + 16 * i, width / 2f - 30, 16), luckProperty);
EditorGUI.PropertyField(new Rect(position.x + width / 2f, position.y + 16 * i, width / 2f - 30, 16), defenseProperty);
EditorGUILayout.EndHorizontal();
i++;
EditorGUILayout.BeginHorizontal();
EditorGUI.PropertyField(new Rect(position.x, position.y + 16 * i, width / 2f - 30, 16), resistanceProperty);
EditorGUI.PropertyField(new Rect(position.x + width / 2f, position.y + 16 * i, width / 2f - 30, 16), constitutionProperty);
EditorGUILayout.EndHorizontal();
i++;
EditorGUILayout.BeginHorizontal();
EditorGUI.PropertyField(new Rect(position.x, position.y + 16 * i, width / 2f - 30, 16), movementProperty);
EditorGUI.PropertyField(new Rect(position.x + width / 2f, position.y + 16 * i, width / 2f - 30, 16), pccProperty, new GUIContent("Critical Coefficient"));
EditorGUILayout.EndHorizontal();
i++;
EditorGUILayout.BeginHorizontal();
EditorGUI.PropertyField(new Rect(position.x, position.y + 16 * i, width / 2f - 30, 16), aidProperty);
//EditorGUI.PropertyField(new Rect(position.x + width / 2f, position.y + 16 * i, width / 2f - 30, 16), pccProperty, new GUIContent("Critical Coefficient"));
EditorGUILayout.EndHorizontal();
i += 2;
EditorGUILayout.BeginHorizontal();
EditorGUI.LabelField(new Rect(position.x, position.y + 16 * i, width / 3.34f - 30, 16), new GUIContent("SP"));
EditorGUI.PropertyField(new Rect(position.x + width / 5, position.y + 16 * i, width / 3.34f - 30, 16), spProperty, new GUIContent(""));
EditorGUI.LabelField(new Rect(position.x + width / 2f, position.y + 16 * i, width / 2f - 30, 16), new GUIContent(TotalEXP.ToString()), new GUIStyle {
alignment = TextAnchor.MiddleRight
});
EditorGUI.LabelField(new Rect(position.x + width / 2f, position.y + 16 * i, width / 2f - 30, 16), new GUIContent("Total experience: "), new GUIStyle {
alignment = TextAnchor.MiddleLeft
});
EditorGUILayout.EndHorizontal();
EditorGUILayout.EndVertical();
}
GUILayout.Space(boxHeight);
displayGrowth = EditorGUILayout.Foldout(displayGrowth, "Stat Growth");
if (displayGrowth)
{
Rect pos = GUILayoutUtility.GetLastRect();
EditorGUI.indentLevel++;
pos.x += 4;
pos.y += 5;
EditorGUI.HelpBox(new Rect(pos.x + 24, pos.y + 11, width - 40, 74), "", MessageType.None);
float i = 1;
EditorGUILayout.BeginVertical();
EditorGUILayout.BeginHorizontal();
EditorGUI.PropertyField(new Rect(pos.x, pos.y + 16 * i, width / 1.95f - 30, 16), hpGrowthProperty, new GUIContent("HP Growth"));
EditorGUI.PropertyField(new Rect(pos.x + width / 2f, pos.y + 16 * i, width / 1.95f - 30, 16), strengthGrowthProperty, new GUIContent("Strength Growth"));
EditorGUILayout.EndHorizontal();
i++;
EditorGUILayout.BeginHorizontal();
EditorGUI.PropertyField(new Rect(pos.x, pos.y + 16 * i, width / 1.95f - 30, 16), magicGrowthProperty, new GUIContent("Magic Growth"));
EditorGUI.PropertyField(new Rect(pos.x + width / 2f, pos.y + 16 * i, width / 1.95f - 30, 16), skillGrowthProperty, new GUIContent("Skill Growth"));
EditorGUILayout.EndHorizontal();
i++;
EditorGUILayout.BeginHorizontal();
EditorGUI.PropertyField(new Rect(pos.x, pos.y + 16 * i, width / 1.95f - 30, 16), speedGrowthProperty, new GUIContent("Speed Growth"));
EditorGUI.PropertyField(new Rect(pos.x + width / 2f, pos.y + 16 * i, width / 1.95f - 30, 16), luckGrowthProperty, new GUIContent("Luck Growth"));
EditorGUILayout.EndHorizontal();
i++;
EditorGUILayout.BeginHorizontal();
EditorGUI.PropertyField(new Rect(pos.x, pos.y + 16 * i, width / 1.95f - 30, 16), defenseGrowthProperty, new GUIContent("Defense Growth"));
EditorGUI.PropertyField(new Rect(pos.x + width / 2f, pos.y + 16 * i, width / 1.95f - 30, 16), resistanceGrowthProperty, new GUIContent("Resistance Growth"));
EditorGUILayout.EndHorizontal();
EditorGUILayout.EndVertical();
EditorGUI.indentLevel--;
GUILayout.Space(74);
}
EditorGUI.indentLevel--;
}
displayRelations = EditorGUILayout.Foldout(displayRelations, "Relationships");
if (displayRelations && relationships != null)
{
int h = 0;
EditorGUI.indentLevel++;
Rect position = GUILayoutUtility.GetLastRect();
position.x += 4;
position.y += 5;
int height = relationships.Count * 16 + 23;
GUILayout.Space(height);
EditorGUI.HelpBox(new Rect(position.x + 8, position.y + 11, width - 31, height), "", MessageType.None);
if (relationships != null)
{
Unit[] keys = new Unit[relationships.Count];
Unit.Relationship[] values = new Unit.Relationship[relationships.Count];
relationships.Keys.CopyTo(keys, 0);
relationships.Values.CopyTo(values, 0);
for (int i = 0; i < keys.Length; i++)
{
GUILayout.BeginHorizontal();
keys[i].name = EditorGUI.TextField(new Rect(position.x, position.y + 16 + 16 * h, width / 2, 16), new GUIContent((i + 1).ToString()), keys[i].name);
values[i].rank = (Unit.Relationship.Rank)EditorGUI.EnumPopup(new Rect(position.x + width / 1.75f, position.y + 16 + 16 * h, width / 8f, 16), new GUIContent(""), values[i].rank);
EditorGUI.LabelField(new Rect(position.x + width / 2, position.y + 16 + 16 * h, width / 3.25f, 16), new GUIContent("Rank"));
bool remove = false;
remove = EditorGUI.Foldout(new Rect(width - width / 4, position.y + 16 + 16 * h, width / 2, 16), remove, new GUIContent("Remove"));
if (remove)
{
relationships.Remove(keys[i]);
}
GUILayout.EndHorizontal();
h++;
}
}
//position = GUILayoutUtility.GetLastRect();
bool add = false;
add = EditorGUI.Foldout(new Rect(position.x, position.y + 16 + 16 * h, width / 2, 16), add, new GUIContent("Add"));
if (add)
{
relationships.Add(CreateInstance <Unit>(), new Unit.Relationship(Unit.Relationship.Rank.None));
}
EditorGUI.indentLevel--;
}
displayInventory = EditorGUILayout.Foldout(displayInventory, "Inventory");
if (displayInventory)
{
EditorGUI.indentLevel++;
Rect position = GUILayoutUtility.GetLastRect();
position.x += 4;
position.y += 5;
int height = Inventory.Size * 16 + 18;
GUILayout.Space(height);
EditorGUI.HelpBox(new Rect(position.x + 8, position.y + 11, width / 2, height), "", MessageType.None);
position.y += 20;
int w = 295 - 36;
for (int i = 0; i < Inventory.Size; i++)
{
Item item = (Item)AssetDatabase.LoadAssetAtPath("Assets/Data/Items/" + _items[i] + ".asset", typeof(Item));
if (item != null)
{
EditorGUI.DrawPreviewTexture(new Rect(position.x + 16, position.y + 16 * i, 16, 16), DataManager.ConvertSpriteToTexture(item.icon));
}
int _width = item != null && item.unbreakable ? w : w - 35;
_items[i] = EditorGUI.TextField(new Rect(width / 2 - w, position.y + 16 * i, _width, 16), _items[i]);
if (item != null && !item.unbreakable)
{
_uses[i] = EditorGUI.IntField(new Rect(width / 2 - 48, position.y + 16 * i, 48, 16), _uses[i]);
}
}
}
GUILayout.BeginHorizontal();
Unit control = CreateInstance <Unit>(), unit = CreateInstance <Unit>();
unit.name = name;
unit.unitClass = unitClass;
unit.unitSex = unitSex;
unit.alignment = alignment;
unit.useable = useable;
unit.affinity = affinity;
unit.stats = stats;
unit.stats.growthRates = stats.growthRates;
unit.relationships = relationships;
for (int i = 0; i < _items.Length; i++)
{
Item item = (Item)AssetDatabase.LoadAssetAtPath("Assets/Data/Items/" + _items[i] + ".asset", typeof(Item));
if (item != null && !item.unbreakable)
{
item.uses = _uses[i];
}
if (item != null)
{
unit.inventory.Add(item);
}
}
if (name != null && name != "" && GUILayout.Button("Export to file"))
{
DataManager.UnitToFile(unit, overrideFile);
}
if (unitFile != null && GUILayout.Button("Read from file"))
{
control = DataManager.FileToUnit(unitFile, true, true);
name = control.name;
unitClass = control.unitClass;
unitSex = control.unitSex;
alignment = control.alignment;
useable = control.useable;
affinity = control.affinity;
relationships = control.relationships;
stats = new Unit.Stats(control.stats, control.stats.growthRates);
inventory = control.inventory.Items;
if (control.inventory.Items == null)
{
control.inventory.Items = new List <Item>();
}
for (int i = 0; i < _items.Length; i++)
{
_items[i] = "";
_uses[i] = 0;
}
for (int i = 0; i < control.inventory.Items.Count; i++)
{
if (control.inventory.Items[i] != null)
{
_items[i] = control.inventory.Items[i].name;
if (!control.inventory.Items[i].unbreakable)
{
_uses[i] = control.inventory.Items[i].uses;
}
}
}
}
GUILayout.EndHorizontal();
EditorGUILayout.EndScrollView();
serializedObject.ApplyModifiedProperties();
}
void StatusMenu(Fighter f)
{
Weapon w = null;
if (hovered.GetType() != typeof(Weapon))
{
if (f.Weapon != null)
{
w = f.Weapon;
}
}
else
{
w = (Weapon)hovered;
}
if (w == null)
{
w = ScriptableObject.CreateInstance <Weapon>();
}
type.text = w.type.ToString().Replace('_', ' ');
bool magic = w.type == Weapon.WeaponType.Anima_Tome || w.type == Weapon.WeaponType.Dark_Tome || w.type == Weapon.WeaponType.Light_Tome;
int str = 0;
float acc = StatsCalc.Accuracy(StatsCalc.HitRate(w.hit, f.Unit.stats.skill, f.Unit.stats.luck, StatsCalc.SupportBonus(f)), StatsCalc.Avoid(f.Unit.stats.speed, f.Unit.stats.luck, new Cell.TerrainBonus(), StatsCalc.SupportBonus(f)), 1);
float crit = StatsCalc.CriticalChance(StatsCalc.CriticalRate(w.crit, f.Unit.stats.skill, StatsCalc.SupportBonus(f), StatsCalc.ClassCrit(f.Unit.unitClass)), 0);
float evade = StatsCalc.Avoid(f.Unit.stats.speed, f.Unit.stats.luck, new Cell.TerrainBonus(), StatsCalc.SupportBonus(f));
if (!magic)
{
str = StatsCalc.PhysicalAttack(f.Unit.stats.strength, w.might, 1, 1, StatsCalc.SupportBonus(f), false);
}
else
{
str = StatsCalc.MagicalAttack(f.Unit.stats.magic, w.might, 1, 1, StatsCalc.SupportBonus(f));
}
atk.text = "ATK: " + str;
this.acc.text = "ACC: " + (int)acc;
crt.text = "CRT: " + (int)crit;
eva.text = "EVA: " + (int)evade;
#region atk
if (str > baseAtk)
{
atkAr.color = inc;
atkAr.transform.localScale = Vector3.one;
_atkAr.gameObject.SetActive(true);
}
else if (str < baseAtk)
{
atkAr.color = dec;
atkAr.transform.localScale = new Vector3(1, -1, 1);
_atkAr.gameObject.SetActive(true);
}
else
{
_atkAr.gameObject.SetActive(false);
}
#endregion
#region acc
if (acc > baseAcc)
{
accAr.color = inc;
accAr.transform.localScale = Vector3.one;
_accAr.gameObject.SetActive(true);
}
else if (acc < baseAcc)
{
accAr.color = dec;
accAr.transform.localScale = new Vector3(1, -1, 1);
_accAr.gameObject.SetActive(true);
}
else
{
_accAr.gameObject.SetActive(false);
}
#endregion
#region crt
if (crit > baseCrt)
{
crtAr.color = inc;
crtAr.transform.localScale = Vector3.one;
_crtAr.gameObject.SetActive(true);
}
else if (crit < baseCrt)
{
crtAr.color = dec;
crtAr.transform.localScale = new Vector3(1, -1, 1);
_crtAr.gameObject.SetActive(true);
}
else
{
_crtAr.gameObject.SetActive(false);
}
#endregion
#region eva
if (evade > baseEva)
{
evaAr.color = inc;
evaAr.transform.localScale = Vector3.one;
_evaAr.gameObject.SetActive(true);
}
else if (evade < baseEva)
{
evaAr.color = dec;
evaAr.transform.localScale = new Vector3(1, -1, 1);
_evaAr.gameObject.SetActive(true);
}
else
{
_evaAr.gameObject.SetActive(false);
}
#endregion
}
public void GetEnemyStats(StatsCalc stats)
{
monster.info = stats.Monster.info;
monster.tempStats = stats.Monster.tempStats;
}
//this is called from the Monster script. information of this enemy is taken from the Monster Script, but new data is added since it's an "Enemy", so it will very likely be its own unique monster
public void SetEnemyStats(int level)
{
var monsters = GameManager.Instance.monstersData.monstersAllDict;
var attacks = GameManager.Instance.baseAttacks.attackDict;
var abilities = GameManager.Instance.GetComponent <MonsterAbilities>().allAbilitiesDict;
var skills = GameManager.Instance.GetComponent <AllSkills>().allSkillsDict;
var allEquips = GameManager.Instance.items.allEquipsDict;
monster.info.name = monster.info.species;
monster.info.maxLevel = monsters[monster.info.species].maxLevel;
monster.info.levelConst = monsters[monster.info.species].levelConst;
monster.info.energyCost = monsters[monster.info.species].energyCost;
monster.info.energyGenBase = monsters[monster.info.species].energyGenBase;
monster.info.type1 = monsters[monster.info.species].type1;
monster.info.type2 = monsters[monster.info.species].type2;
monster.info.dexId = monsters[monster.info.species].id;
monster.info.hpBase = monsters[monster.info.species].hpBase;
monster.info.atkBase = monsters[monster.info.species].atkBase;
monster.info.defBase = monsters[monster.info.species].defBase;
monster.info.speBase = monsters[monster.info.species].speBase;
monster.info.precBase = monsters[monster.info.species].precBase;
monster.info.staminaBase = monsters[monster.info.species].staminaBase;
monster.info.Class = monsters[monster.info.species].Class;
monster.info.coinGenBase = monsters[monster.info.species].coinGenBase;
monster.info.level = level;
int starChance = monsters[monster.info.species].starChance;
int randStar = Random.Range(0, 500);
if (randStar <= starChance)
{
monster.info.isStar = true;
monster.bodyParts.StarMonster();
}
if (allEquips.ContainsKey(monster.info.equip1Name))
{
EquipmentScript eq = Instantiate(allEquips[monster.info.equip1Name]);
monster.info.equip1 = new Equipment(eq);
}
else
{
monster.info.equip1 = null;
}
if (allEquips.ContainsKey(monster.info.equip2Name))
{
EquipmentScript eq = Instantiate(allEquips[monster.info.equip2Name]);
monster.info.equip2 = new Equipment(eq);
}
else
{
monster.info.equip2 = null;
}
//set the monster's ability'
if (monsters[monster.info.species].abilities.Length > 1)
{
int ab = Random.Range(0, monsters[monster.info.species].abilities.Length - 1);
monster.info.abilityName = monsters[monster.info.species].abilities[ab];
}
else
{
monster.info.abilityName = monsters[monster.info.species].abilities[0];
}
//set the monster's skill
if (monsters[monster.info.species].skills.Length > 1)
{
int sk = Random.Range(0, monsters[monster.info.species].skills.Length - 1);
monster.info.skillName = monsters[monster.info.species].skills[sk];
}
else
{
monster.info.skillName = monsters[monster.info.species].skills[0];
}
//set the monster's first 2 base attacks
int rand = Random.Range(0, monsters[monster.info.species].baseAttacks.Length - 1);
monster.info.attack1Name = monsters[monster.info.species].baseAttacks[rand];
int rand2 = Random.Range(0, monsters[monster.info.species].baseAttacks.Length - 1);
monster.info.attack2Name = monsters[monster.info.species].baseAttacks[rand2];
monster.info.specialAbility = new MonsterAbility(abilities[monster.info.abilityName], monster);
monster.info.passiveSkill = new PassiveSkill(monster, skills[monster.info.skillName]);
StartCoroutine(monster.WeatherCheck());
int hpRand = Random.Range(0, 26);
int defRand = Random.Range(0, 26);
int speRand = Random.Range(0, 26);
StatsCalc StatsCalc = new StatsCalc(monster);
GetEnemyStats(StatsCalc);
monster.info.currentHP = monster.info.maxHP;
enemyHpSlider.maxValue = monster.info.maxHP;
enemyHpSlider.value = monster.info.currentHP;
speed = 40 * ((float)monster.info.speBase / 100);
}
//****************The following methods are for calculating the stats of the monster***********//
public void GetStats(StatsCalc stats)
{
info = stats.Monster.info;
tempStats = stats.Monster.tempStats;
SaveMonsterToken();
}
