public void OnUpdate(SkillAttribute model)
{
Open();
this.model = model;
iconImage.sprite = Manage.Instance.AB.GetGame <Sprite>(AssetbundleEnum.SkillIcon, model.icon);
nameText.text = model.name;
}
void UpdataSkillAttribute()
{
skillAttribute = new BaseAttribute();
SkillAttribute _skill = null;
if (dataModel.skillArray == null)
{
return;
}
for (int i = 0; i < dataModel.skillArray.Length; i++)
{
for (int j = 0; j < dataModel.skillArray[i].skillAry.Count; j++)
{
_skill = Manage.Instance.Data.GetObj <SkillAttribute>(dataModel.skillArray[i].skillAry[j]);
if (_skill.triggerType == 1)
{
continue;
}
if (_skill.effectType.Length == 0)
{
continue;
}
if (_skill.effectType[0] != 6)
{
continue;
}
if (_skill.IsNeedEquipment(dataModel) == false)
{
continue;
}
_skill.additionalAttribute.Additional(finalAttribute, skillAttribute);
}
}
}
public virtual void Enter(Unit unit, SkillAttribute model, HexCell target, Action skillEnd)
{
this.unit = unit;
this.target = target;
this.skillEnd = skillEnd;
attribute = model;
start();
unit.animation.AddEvent(IntEvent, FolatEvent, StringEvent, ObjEvent);
}
public bool ActivateSkillCheck(SkillAttribute skillAttribute, int playerScore, int opposingScore)
{
if (_currentChaosBag == null)
{
Debug.LogError("SkillCheckManager.ActivateSkillCheck :: Chaos Bag is null");
return(false);
}
// TODO check if player wants to discard playable card
playerScore += DrawFromChaosBag();
return(playerScore >= opposingScore);
}
private void SetSkillType(MemberInfo method)
{
SkillAttribute skillAttribute =
System.Attribute.GetCustomAttribute(method, typeof(SkillAttribute)) as SkillAttribute;
if (skillAttribute == null)
{
Debug.Log("Method's skill type is missing!");
return;
}
SkillType = skillAttribute.SkillType;
EarnedXp = skillAttribute.EarnedXp;
}
public void UpdateSkill(SkillAttribute skill, Unit unit)
{
type = 3;
model = skill;
icon.sprite = Manage.Instance.AB.GetGame <Sprite>(AssetbundleEnum.SkillIcon, skill.icon);
int needAp = skill.GetAP(unit.DataModel.finalAttribute);
Interactable(unit.CurrentAP >= needAp);
number.color = unit.CurrentAP >= needAp ? Color.white : Color.red;
number.text = needAp.ToString();
if (skill.IsNeedEquipment(unit.DataModel.dataModel) == false)
{
mask.SetActive(true);
return;
}
Open();
}
public override void Enter(object[] obj)
{
base.Enter(obj);
MoveTargetCell = obj[0] as NavCell;
if (obj.Length > 1)
{
AtkTarget = obj[1] as HexCell;
seleSkill = obj[2] as SkillAttribute;
}
if (MoveTargetCell.cell == owner.CurrentUnit.cell)
{
MoveEnd();
}
else
{
BattleManager.ChangeState(GameState.moveing);
StartCoroutine(Swquence());
}
}
public int ValueOf(SkillAttribute attr)
{
switch (attr)
{
case SkillAttribute.Charisma:
return(Charisma);
case SkillAttribute.Intelligence:
return(Intelligence);
case SkillAttribute.Memory:
return(Memory);
case SkillAttribute.Perception:
return(Perception);
case SkillAttribute.Willpower:
return(Willpower);
}
return(-1);
}
void OnClick(bool ison, string name)
{
if (ison == false)
{
return;
}
int type = int.Parse(name);
if (TabToggle[type].isOn == false)
{
TabToggle[type].isOn = true;
}
List <SkillAttribute> skill = new List <SkillAttribute>();
for (int i = 0; i < character.dataModel.skillArray[type].skillAry.Count; i++)
{
int skillid = character.dataModel.skillArray[type].skillAry[i];
SkillAttribute _skill = Manage.Instance.Data.GetObj <SkillAttribute>(skillid);
skill.Add(_skill);
}
int count = skill.Count - statsGame.Count;
for (int i = 0; i < count; i++)
{
GameObject obj = Instantiate(SkillStatsGamePrefab);
obj.SetParent(skillGrid);
SkillStatsGame game = obj.AddComponent <SkillStatsGame>();
game.mAwake(OnClickSkillStats);
statsGame.Add(game);
}
for (count = 0; count < skill.Count; count++)
{
statsGame[count].OnUpdate(skill[count]);
}
for (; count < statsGame.Count; count++)
{
statsGame[count].Close();
}
}
void UpdateSkill(Unit unit)
{
int count = 0;
for (int i = 0; i < unit.DataModel.dataModel.skillArray.Length; i++)
{
for (int j = 0; j < unit.DataModel.dataModel.skillArray[i].Count; j++)
{
SkillAttribute skill = Manage.Instance.Data.GetObj <SkillAttribute>(unit.DataModel.dataModel.skillArray[i].skillAry[j]);
if (skill.triggerType != 1)
{
continue;
}
GetSkillItem(count).UpdateSkill(skill, unit);
count++;
}
}
for (count--; count < SkillItem.Count; count++)
{
SkillItem[count].Close();
}
}
public float GetAttribute(SkillAttribute at)
{
switch (at)
{
case SkillAttribute.effectAmount:
return(effectAmount);
case SkillAttribute.duration:
return(duration);
case SkillAttribute.cooldown:
return(cooldown);
case SkillAttribute.cost:
return(cost);
case SkillAttribute.maxEnemiesHit:
return((float)maxEnemiesHit);
default:
return(-1f);
}
}
private string SkillAttributeToString(SkillAttribute sa)
{
switch (sa)
{
case SkillAttribute.cooldown:
case SkillAttribute.cost:
case SkillAttribute.duration:
return(sa.ToString());
break;
case SkillAttribute.effectAmount:
return("effect amount");
break;
case SkillAttribute.maxEnemiesHit:
return("max enemies hit");
break;
}
return("");
}
public static float GetSkillBonusForDuration(Responsible responsible, float duration)
{
SkillAttribute skillAttribute = System.Attribute.GetCustomAttribute(responsible.GetCurrentJob().Method, typeof(SkillAttribute)) as SkillAttribute;
if (skillAttribute == null)
{
return(duration);
}
var reducedDuration = duration;
if (responsible.Skills.ContainsKey(skillAttribute.SkillType))
{
reducedDuration *= (float)
(responsible.Skills[skillAttribute.SkillType].MaxLevel -
responsible.Skills[skillAttribute.SkillType].Level + 1) /
responsible.Skills[skillAttribute.SkillType].MaxLevel;
}
Debug.Log("Reduced duration: " + reducedDuration);
return(reducedDuration);
}
public override void OnUpdate()
{
if (!gameObject.activeSelf)
{
return;
}
NameText.text = attribute.dataModel.name;
attributePanel.Character = attribute;
//TODO
{
attributePanel.Character.dataModel.skillArray = new global::SkillSaveModel[(int)skillEnum.length];
for (int i = 0; i < attributePanel.Character.dataModel.skillArray.Length; i++)
{
attributePanel.Character.dataModel.skillArray[i] = new SkillSaveModel(i);
}
var _array = Manage.Instance.Data.GetObjAry <SkillAttribute>();
for (int i = 0; i < _array.Count; i++)
{
SkillAttribute _skill = _array[i];
attributePanel.Character.dataModel.skillArray[(int)_skill.skillType].skillAry.Add(_skill.id);
}
}
skillPanel.Character = attribute;
}
void OnGUI()
{
nameSkill = EditorGUILayout.TextField("Name", nameSkill);
folderName = EditorGUILayout.TextField("Save folder", folderName);
description = EditorGUILayout.TextField("Description", description);
skillLevel = EditorGUILayout.IntField("Start skill level", skillLevel);
skillShot = EditorGUILayout.Toggle("Is a skillshot", skillShot);
string assetPath = "Assets/Prefabs/Skills/SkillGUI/";
string[] search_results = null;
search_results = System.IO.Directory.GetFiles(assetPath, "*.prefab", System.IO.SearchOption.AllDirectories);
indexAreaSkillshot = EditorGUILayout.Popup("Area skillshot", indexAreaSkillshot, search_results);
targetted = EditorGUILayout.Toggle("Is a targetted skill", targetted);
passive = EditorGUILayout.Toggle("Is a passive skill", passive);
targetSelf = EditorGUILayout.Toggle("Can hit sender", targetSelf);
targetEnemies = EditorGUILayout.Toggle("Can hit enemies", targetEnemies);
if (targetEnemies)
{
int cpt = 0;
foreach (UnitType type in Enum.GetValues(typeof(UnitType)))
{
targettableEnemies[cpt] = EditorGUILayout.Toggle(type.ToString(), targettableEnemies[cpt]);
cpt++;
}
EditorGUILayout.Space();
}
targetFriendlies = EditorGUILayout.Toggle("Can hit friendlies", targetFriendlies);
if (targetFriendlies)
{
int cpt = 0;
foreach (UnitType type in Enum.GetValues(typeof(UnitType)))
{
targettableFriendlies[cpt] = EditorGUILayout.Toggle(type.ToString(), targettableFriendlies[cpt]);
cpt++;
}
EditorGUILayout.Space();
}
initialPosition = (InitialPositionState)EditorGUILayout.EnumPopup("Initial position", initialPosition);
levelRequired = EditorGUILayout.IntField("Level required", levelRequired);
levelAttributesModifiersSize = EditorGUILayout.IntField("Skill levels", levelAttributesModifiersSize);
if (levelAttributesModifiersSize > attributesModifiers.Count)
{
while (levelAttributesModifiersSize > attributesModifiers.Count)
{
attributesModifiers.Add(new ListSkillAttributes());
attributesModifiersSizes.Add(new int());
}
}
else if (levelAttributesModifiersSize < attributesModifiers.Count)
{
while (levelAttributesModifiersSize < attributesModifiers.Count)
{
attributesModifiers.RemoveAt(attributesModifiers.Count - 1);
attributesModifiersSizes.RemoveAt(attributesModifiersSizes.Count - 1);
}
}
for (int i = 0; i < attributesModifiers.Count; i++)
{
GUIStyle gstyleTextLevel = new GUIStyle(GUI.skin.textArea);
gstyleTextLevel.margin.left += 10;
GUIStyle gstyleTextAttributes = new GUIStyle(GUI.skin.textArea);
gstyleTextAttributes.margin.left += 20;
GUIStyle gstyleEnum = new GUIStyle(GUI.skin.GetStyle("MiniToolbarPopup"));
gstyleEnum.margin.left += 24;
attributesModifiersSizes[i] = EditorGUILayout.IntField("Level " + (i + 1) + " modifiers", attributesModifiersSizes[i], gstyleTextLevel);
if (attributesModifiers[i].skillAttributes == null)
{
ListSkillAttributes lsa = new ListSkillAttributes();
lsa.skillAttributes = new List <SkillAttribute>();
attributesModifiers[i] = lsa;
}
if (attributesModifiersSizes[i] > attributesModifiers[i].skillAttributes.Count)
{
while (attributesModifiersSizes[i] > attributesModifiers[i].skillAttributes.Count)
{
attributesModifiers[i].skillAttributes.Add(new SkillAttribute());
}
}
else if (attributesModifiersSizes[i] < attributesModifiers[i].skillAttributes.Count)
{
while (attributesModifiersSizes[i] < attributesModifiers[i].skillAttributes.Count)
{
attributesModifiers[i].skillAttributes.RemoveAt(attributesModifiers[i].skillAttributes.Count - 1);
}
}
for (int j = 0; j < attributesModifiers[i].skillAttributes.Count; j++)
{
SkillAttribute sa = new SkillAttribute();
sa.nameSkillAttribute = (NameSkillAttribute)EditorGUILayout.EnumPopup("Attribute name", attributesModifiers[i].skillAttributes[j].nameSkillAttribute, gstyleEnum);
sa.value = EditorGUILayout.FloatField("Value", attributesModifiers[i].skillAttributes[j].value, gstyleTextAttributes);
attributesModifiers[i].skillAttributes[j] = sa;
}
EditorGUILayout.Space();
}
ps_skill = (GameObject)EditorGUILayout.ObjectField("Particle System", ps_skill, typeof(GameObject), true);
if (GUILayout.Button("Add new skill"))
{
AddNewSkill(search_results);
}
}
public void Open(SkillAttribute attribute)
{
Attribute = attribute;
base.Open();
}
void OnClickSkillStats(SkillAttribute model)
{
PanelManager.Instantiate.SkillStatsPanel.Open(model, character);
}
public bool HaveSkill(SkillAttribute model)
{
return(skillArray[(int)model.skillType].skillAry.Contains(model.id));
}
public static uint GetPlayerSkill(Skills skill, SkillAttribute attr)
{
if(skill < Skills.Last && attr < SkillAttribute.Last)
{
return playerSkills[(int)skill, (int)attr];
}
return 0;
}
public static void SetPlayerSkill(Skills skill, SkillAttribute attr, uint value)
{
if(skill < Skills.Last && attr < SkillAttribute.Last)
{
playerSkills[(int)skill, (int)attr] = value;
}
}
public void Open(SkillAttribute attribute, UnitModel character)
{
Character = character;
Open(attribute);
}
public override void Enter(object[] obj)
{
model = obj[0] as SkillAttribute;
FindAtkRange(model.releaseRange, 0);
}
public Upgrade(float amt, SkillAttribute name, int lvl)
{
upgradeAmt = amt;
attributeToUpgrade = name;
lvlRequirement = lvl;
}
public void Enter(Unit unit)
{
this.unit = unit;
SkillAttribute _skill = SeleAction();
if (move_maxRange <= 0)
{
owner.Unitmanager.NoActive();
owner.ChangeState <SelectUnitBattleState>();
return;
}
var nav = HexGrid.Instantiate.GetRange(unit.cell, move_maxRange, move_minRange, this.unit.IsAtk);
List <Unit> units = new List <Unit>();
for (int i = 0; i < nav.Count; ++i)
{
if (nav[i].unit != null)
{
if (nav[i].unit.IsDie)
{
continue;
}
if (nav[i].unit.ranks == unit.ranks)
{
continue;
}
units.Add(nav[i].unit);
}
}
HexCell Atk_Target = null;
NavCell target = null;
List <NavCell> path = new List <NavCell>();
if (units.Count() == 0)
{
path = GetPath();
}
else
{
Atk_Target = Manage.Instance.Battle.Unitmanager.GetMaxValue(unit.ranks, units).cell;
List <NavCell> atkCell = HexGrid.Instantiate.GetAtkCell(Atk_Target, atk_maxRange, atk_minRange, unit.AtkRange);
List <NavCell> moveCell = HexGrid.Instantiate.GetMoveRangePath(this.unit.cell,
//this.unit.DataModel[DataEnum.move],
move_maxRange,
this.unit.IsMove);
var _range = moveCell.Intersect(atkCell, new NavCell.StudentComparer()).ToList();
//var _cell = atkCell.Find(a => a.cell == owner.CurrentUnit.cell);
//if (_cell != null)
//{
// _range.Add(_cell);
//}
if (_range.Count == 0)
{
path = GetPath();
Atk_Target = null;
}
else
{
_range.Sort((a, b) => b.GetValue(unit).CompareTo(a.GetValue(unit)));
target = _range[0];
if (target.cell != unit.cell)
{
path = HexGrid.Instantiate.GetPath(this.unit.cell, target.cell,
this.unit.DataModel[DataEnum.move],
this.unit.IsMove);
}
}
}
if (path.Count > 0)
{
if (path[0].cell.unit != null)
{
path.RemoveAt(0);
}
}
if (path.Count > 0)
{
target = path[0];
}
if (target == null)
{
owner.Unitmanager.NoActive();
owner.ChangeState <SelectUnitBattleState>();
return;
}
owner.ChangeState <MoveBattleState>(target, Atk_Target, _skill);
}
