private Skill(uint skillID, string skillName, SkillType type, SkillProperty property, SkillCost cost, string desc)
{
SkillID = skillID;
SkillName = skillName;
SkillType = type;
Property = property;
Cost = cost;
Description = desc;
}
public string ResourcesDir = ""; //资源路径
public void Skill(SkillProperty skillProperty)
{
if (skillProperty.flashing <= 0) //未在冷却
{
skillProperty.flashing = skillProperty.flash; //重置冷却
{
//技能动画
heroAnime.StartSkill(skillProperty.skillName);
//产生技能子弹
Vector3 offset = gameObject.transform.position;
//调整子弹位置
bool xDir = gameObject.GetComponent <Character>().xDirection;
if (xDir)
{
offset.x += skillProperty.xOffset;
}
else
{
offset.x -= skillProperty.xOffset;
}
offset.y += skillProperty.yOffset;
GameObject skillBullet = Instantiate(skillDict[skillProperty.skillName + "Bullet"],
offset, transform.rotation);
if (skillBullet.GetComponent <BulletBase>().kind == 1)
{
skillBullet.transform.SetParent(gloableBullet.transform, true);
}
else
{
skillBullet.transform.SetParent(gameObject.transform, true);
}
//确定方向
//float x = -1;
//if (gameObject.GetComponent<Character>().xDirection)
// x = 1;
//skill1Bullet.GetComponent<BulletBase>().direction = new Vector2(x, 0);
skillBullet.GetComponent <BulletBase>().xDirection = xDir;
skillBullet.GetComponent <BulletBase>().belong = gameObject;
//确定子弹技能伤害
skillBullet.GetComponent <BulletBase>().damage = skillProperty.damage;
}
//后摇僵直
GetComponent <Character>().action = false;
herorigidbody.velocity = new Vector2(0, 0);
//重置后摇时间
skillProperty.staying = skillProperty.stay;
//延时结束技能动画
StartCoroutine(SkillAnimeEnd(skillProperty.skillName, skillProperty.animeTime));
}
}
Rect CreateSkillBt(Transform skill, int seg)
{
SkillProperty sProperty = skill.GetComponent <SkillProperty>();
Texture2D manaCost = numIcon.GetManaTexture(sProperty.SkillCost);
Rect manaRect = new Rect(btSize + leftMargin + 5, topMargin + segment * 3 + 50 + 30 * seg, 16, 16);
Rect skillNameRect = new Rect(btSize + leftMargin + 22, topMargin + segment * 3 + 50 + 30 * seg, 150, 30);
GUI.DrawTexture(manaRect, manaCost);
GUI.Label(skillNameRect, sProperty.SkillName, subStyle);
return(new Rect(manaRect.x, manaRect.y, manaRect.width + skillNameRect.width, skillNameRect.height));
}
public static GenericMenu GeneratePropertyMenu(SkillProperty fsmProperty)
{
TypeHelpers.targetFsmProperty = fsmProperty;
GenericMenu result = new GenericMenu();
Type globalType = ReflectionUtils.GetGlobalType(fsmProperty.TargetTypeName);
if (globalType != null)
{
TypeHelpers.AddPropertyMenuItems(ref result, globalType, "", 0, fsmProperty.setProperty);
}
return(result);
}
public Skill(IObject obj, int skillId)
{
if (mSkillProperty != null)
{
return;
}
mSelfObj = obj;
mSkillId = skillId;
mSkillProperty = XmlManager.Instance.GetSkillProperty(mSkillId);
}
public Transform GetSkill(Transform chess)
{
Transform theSkill = null;
Transform[] skills = chess.GetComponent <SkillSets>().Skills;
foreach (Transform skill in skills)
{
SkillProperty skillProperty = skill.GetComponent <SkillProperty>();
if (skillProperty.SType == SkillType.EnhanceSelf)
{
theSkill = skill;
break;
}
}
return(theSkill);
}
private static void OpenSubPropertyMenu()
{
SkillEditor.OnRepaint = (SkillEditor.RepaintDelegate)Delegate.Remove(SkillEditor.OnRepaint, new SkillEditor.RepaintDelegate(TypeHelpers.OpenSubPropertyMenu));
string text = TypeHelpers.subPropertyPath;
SkillProperty fsmProperty = TypeHelpers.targetFsmProperty;
GenericMenu genericMenu = new GenericMenu();
Type globalType = ReflectionUtils.GetGlobalType(fsmProperty.TargetTypeName);
if (globalType != null)
{
string path = TypeHelpers.NicifyPropertyPath(text);
Type propertyType = ReflectionUtils.GetPropertyType(globalType, text);
TypeHelpers.AddPropertyMenuItems(ref genericMenu, propertyType, path, 0, fsmProperty.setProperty);
}
TypeHelpers.subPropertyPath = "";
genericMenu.ShowAsContext();
}
bool LoadSkillProperty()
{
byte[] asset = ResourceManager.Instance.GetXml("SkillProperty");
if (asset == null)
{
return(false);
}
TbXmlNode docNode = TbXml.Load(asset).docNode;
if (docNode == null)
{
return(false);
}
List <TbXmlNode> xmlNodeList = docNode.GetNodes("SkillProperty/Property");
int xmlNodeListLength = xmlNodeList.Count;
if (xmlNodeListLength < 1)
{
return(false);
}
for (int i = 0; i < xmlNodeListLength; ++i)
{
SkillProperty sp = new SkillProperty();
TbXmlNode node = xmlNodeList[i] as TbXmlNode;
sp.mSkillId = node.GetIntValue("No");
sp.mSkillName = node.GetStringValue("Name");
sp.mSkillOwnerId = node.GetIntValue("Model");
sp.mSkillIndex = node.GetIntValue("SkillNumber");
sp.mSkillSpace = node.GetFloatValue("SkillSpace");
sp.mSkillConsumptionType = (SkillConsumptionType)node.GetIntValue("SkillConsumptionType");
sp.mSkillConsumptionValue = node.GetIntValue("SkillConsumptionValue");
sp.mAnimatorSkillProperty = new AnimatorSkillProperty();
mSkillPropertyDic.Add(sp.mSkillId, sp);
}
return(true);
}
public static GenericMenu GenerateObjectTypesMenu(SkillProperty fsmProperty)
{
TypeHelpers.RebuildTypeList();
TypeHelpers.targetFsmProperty = fsmProperty;
GenericMenu genericMenu = new GenericMenu();
using (List <Type> .Enumerator enumerator = TypeHelpers.ObjectTypeList.GetEnumerator())
{
while (enumerator.MoveNext())
{
Type current = enumerator.get_Current();
string fullName = current.get_FullName();
if (fullName != null)
{
string text = fullName.Replace('.', '/');
genericMenu.AddItem(new GUIContent(text), false, new GenericMenu.MenuFunction2(TypeHelpers.SetFsmPropertyTargetType), fullName);
}
}
}
return(genericMenu);
}
public int CalculateAttack(SkillProperty skill, SkillDefProperty receiver, bool isNormalAtk, HeaderProto.ESkillEffect byskilleffect, out bool isSuper, out bool bDodge)
{
//首先判断是否命中...
isSuper = false;
bDodge = false;
float hitRate = skill.hitRate - receiver.dodgeRate;
if (hitRate <= 0.0f)
{
bDodge = true;
return(0);
}
int hit = Random.Range(0, 10001);
if (hit > (int)(hitRate * 10000))
{
bDodge = true;
return(0);
}
//判断是否暴击...
float superAttack = 0.0f;
float superRate = skill.superRate - receiver.toughness;
if (superRate > 0.0f)
{
int super = Random.Range(0, 10001);
if (super <= (int)(superRate * 10000))
{
isSuper = true;
superAttack = skill.superAttack - receiver.superDef;
if (superAttack < 1.0f)
{
superAttack = 1.0f;
}
skill.atk = (int)((float)skill.atk * superAttack);
skill.iceAtk = (int)((float)skill.iceAtk * superAttack);
skill.fireAtk = (int)((float)skill.fireAtk * superAttack);
skill.thunderAtk = (int)((float)skill.thunderAtk * superAttack);
skill.poisonAtk = (int)((float)skill.poisonAtk * superAttack);
}
}
float attPerSec = skill.attPerSecond;
int def = receiver.def;
if (skill.type == SkillType.Skill_Ice)
{
def = receiver.iceDef;
}
else if (skill.type == SkillType.Skill_Fire)
{
def = receiver.fireDef;
}
else if (skill.type == SkillType.Skill_Poison)
{
def = receiver.poisonDef;
}
else if (skill.type == SkillType.Skill_Thunder)
{
def = receiver.thunderDef;
}
def = (int)(def * (1.0f - skill.passThrough));
//计算减伤...
float hurtDec = def / ((float)def + receiver.level * 270 + 2700);
//计算最终伤害...
int damage = (int)((((skill.atk + skill.iceAtk + skill.fireAtk + skill.poisonAtk + skill.thunderAtk) * skill.Y + skill.Z) *
(1.0f + skill.YZFix) + skill.ZFix) * skill.damagePer);
//伤害附加 减伤
int hurt = 0;
if (byskilleffect == HeaderProto.ESkillEffect.SKILL_EFFECT_CURE_HP ||
byskilleffect == HeaderProto.ESkillEffect.SKILL_EFFECT_CURE_MP)
{
hurt = damage;
}
else
{
hurt = (int)(damage * (1.0f + skill.hurtOtherModify + skill.PropertyModify + skill.BodyTypeModify + skill.StateModify) * (1.0f - hurtDec) * (1.0f + receiver.beHurtModify));
}
if (hurt <= 0)
{
hurt = Random.Range(1, 6);
}
return(hurt);
}
//virtual protected void CastSkill(Transform skillTrans) //施放指定技能
//{
// if (skillTrans.GetComponent<SkillProperty>().flashing <= 0) //未在冷却
// {
// skillTrans.GetComponent<SkillProperty>().flashing = skillTrans.GetComponent<SkillProperty>().flash; //重置冷却
// gameObject.GetComponent<Hero1Skill>().Skill
// (skillTrans.gameObject.GetComponent<SkillProperty>().skillName); //施放skill
// //后摇僵直
// GetComponent<Character>().action = false;
// herorigidbody.velocity = new Vector2(0, 0);
// //重置后摇时间
// skillTrans.GetComponent<SkillProperty>().staying = skillTrans.GetComponent<SkillProperty>().stay;
// }
//}
virtual protected void CastSkill(SkillProperty skillProperty) //施放指定技能
{
heroSkill.Skill
(skillProperty); //施放skill
}
IEnumerator State(shuxing enemyshuxing, SkillProperty name, float addState, float keeptime)
{
switch (name)
{
case SkillProperty.Attack:
if (keeptime <= 0)
{
enemyshuxing.Attack1 += addState;
}
else
{
enemyshuxing.Attack1 += addState;
yield return(new WaitForSeconds(keeptime));
enemyshuxing.Attack1 -= addState;
}
break;
case SkillProperty.DEF:
if (keeptime <= 0)
{
enemyshuxing.DEF1 += addState;
}
else
{
enemyshuxing.DEF1 += addState;
yield return(new WaitForSeconds(keeptime));
enemyshuxing.DEF1 -= addState;
}
break;
case SkillProperty.Field:
if (keeptime <= 0)
{
enemyshuxing.Field1 += addState;
}
else
{
enemyshuxing.Field1 += addState;
yield return(new WaitForSeconds(keeptime));
enemyshuxing.Field1 -= addState;
}
break;
case SkillProperty.HP:
if (keeptime <= 0)
{
enemyshuxing.HP1 += addState;
}
else
{
enemyshuxing.HP1 += addState;
yield return(new WaitForSeconds(keeptime));
enemyshuxing.HP1 -= addState;
}
break;
case SkillProperty.HPre:
if (keeptime <= 0)
{
enemyshuxing.HPre1 += addState;
}
else
{
enemyshuxing.HPre1 += addState;
yield return(new WaitForSeconds(keeptime));
enemyshuxing.HPre1 -= addState;
}
break;
case SkillProperty.MoveSpeed:
if (keeptime <= 0)
{
enemyshuxing.MoveSpeed1 += addState;
}
else
{
enemyshuxing.MoveSpeed1 += addState;
yield return(new WaitForSeconds(keeptime));
enemyshuxing.MoveSpeed1 -= addState;
}
break;
}
}
public void ShangHaiJiSuan(shuxing enemyshuxing, SkillProperty name, float addState, float keeptime)
{
StartCoroutine(State(enemyshuxing, name, addState, keeptime));
}
public static GenericMenu GeneratePropertyMenu(SkillProperty fsmProperty)
{
return(TypeHelpers.GeneratePropertyMenu(fsmProperty));
}
protected override void InternalDispose()
{
this.property.OnChanged -= this._OnAttrChanged;
this.property = null;
this._data = null;
}
public DamageResult testHurt(sdActorInterface _gameActor, Hashtable _state, sdActorInterface targetActor, int hitPointIndex, HeaderProto.ESkillEffect bySkillEffect)
{
DamageResult dr;
dr.damage = 0;
dr.bubbleType = Bubble.BubbleType.eBT_BaseHurt;
dr.attracker = _gameActor;
Hashtable recProp = targetActor.GetProperty();
if (recProp == null)
{
return(dr);
}
SkillProperty skillProp = new SkillProperty();
int dmgMin = (int)_gameActor["AtkDmgMin"];
int dmgMax = (int)_gameActor["AtkDmgMax"];
int iceAtt = (int)_gameActor["IceAtt"];
int fireAtt = (int)_gameActor["FireAtt"];
int poisonAtt = (int)_gameActor["PoisonAtt"];
int thunerAtt = (int)_gameActor["ThunderAtt"];
int intervalPerAttack = (int)_gameActor["AttSpeed"]; // ms per attack
float attackPerSecond = 1000.0f / (float)intervalPerAttack;
int d10000 = ((int[])_state["dwAtkPowerPer[10]"])[hitPointIndex];
int dx = ((int[])_state["dwDmg[10]"])[hitPointIndex];
int byPeriodicDamageType = 0; //(int)_state.stateData["byPeriodicDamage"];
Hashtable attTable = new Hashtable();
int phyAtt = dmgMin;
//如果最小攻击力 大于 最大攻击力 直接取最小攻击力...
if (dmgMax > dmgMin)
{
phyAtt = Random.Range(dmgMin, dmgMax);
}
float iPercentFix = 0.0f;
int iDamageFix = 0;
switch ((EPeriodicDamage)byPeriodicDamageType)
{
///每波伤害相同...
case EPeriodicDamage.PERIODIC_DAMAGE_SAME: {} break;
///固定值递增：Data + DataPeriodic * (Index)...
case EPeriodicDamage.PERIODIC_DAMAGE_INCREASE: {
iDamageFix = (int)_state["dwPeriodicTraumaHP"] * (hitPointIndex + 1);
} break;
///百分比递增：HP*(Data + DataPeriodic * (Index))...
case EPeriodicDamage.PERIODIC_DAMAGE_INCREASE_PERCENT: {
iPercentFix = ((int)_state["dwPeriodicTraumaHP"] / 10000.0f) * (hitPointIndex + 1);
} break;
///固定值递减：Data - DataPeriodic * (Index)...
case EPeriodicDamage.PERIODIC_DAMAGE_DECREASE: {
iDamageFix = -(int)_state["dwPeriodicTraumaHP"] * (hitPointIndex + 1);
} break;
///百分比递减：HP*(Data - DataPeriodic * (Index))...
case EPeriodicDamage.PERIODIC_DAMAGE_DECREASE_PERCENT: {
iPercentFix = -((int)_state["dwPeriodicTraumaHP"] / 10000.0f) * (hitPointIndex + 1);
} break;
///第一波伤害最大,其余伤害相同,第一波伤害计算公式：...
///固定值方式：Data - DataPeriodic...
case EPeriodicDamage.PERIODIC_DAMAGE_FIRST: {
if (hitPointIndex == 0)
{
iDamageFix = (int)_state["dwPeriodicTraumaHP"];
}
} break;
///百分比方式：HP*(Data + DataPeriodic)...
case EPeriodicDamage.PERIODIC_DAMAGE_FIRST_PERCENT: {
if (hitPointIndex == 0)
{
iPercentFix = ((int)_state["dwPeriodicTraumaHP"] / 10000.0f);
}
} break;
///最后一波伤害最大,其余伤害相同,第一波伤害计算公式：
///固定值方式：Data + DataPeriodic
case EPeriodicDamage.PERIODIC_DAMAGE_END: {
if (hitPointIndex == -1)
{
iPercentFix = (int)_state["dwPeriodicTraumaHP"];
}
} break;
///百分比方式：HP*(Data + DataPeriodic)...
case EPeriodicDamage.PERIODIC_DAMAGE_END_PERCENT: {
if (hitPointIndex == -1)
{
iPercentFix = ((int)_state["dwPeriodicTraumaHP"] / 10000.0f);
}
} break;
}
int skillHit = (int)_state["dwHitPer"];
int skillCri = (int)_state["dwCriticalPer"];
int skillCriDmg = (int)_state["dwCriticalDmgPer"];
skillProp.atk = phyAtt;
skillProp.iceAtk = iceAtt;
skillProp.fireAtk = fireAtt;
skillProp.poisonAtk = poisonAtt;
skillProp.thunderAtk = thunerAtt;
skillProp.Y = (float)d10000 / 10000.0f;
skillProp.Z = dx;
skillProp.YZFix = iPercentFix;
skillProp.ZFix = iDamageFix;
skillProp.hitRate = (float)_gameActor["Hit"] * fPropertyScale + (float)_gameActor["HitPer"] * 0.0001f + (skillHit) * 0.0001f;
int pierce = _gameActor["Pierce"];
skillProp.passThrough = (float)pierce / (float)(pierce + (int)recProp["Level"] * 270 + 2700);
skillProp.superAttack = (float)_gameActor["CriDmg"] * 0.0001f + (skillCriDmg) * 0.0001f;
skillProp.superRate = (float)_gameActor["Cri"] * fPropertyScale + (float)_gameActor["CriPer"] * 0.0001f + (skillCri) * 0.0001f;
skillProp.attPerSecond = attackPerSecond;
if (_state.ContainsKey("dwDamagePer"))
{
skillProp.damagePer = ((int)_state["dwDamagePer"]) * 0.0001f;
}
else
{
skillProp.damagePer = 1.0f;
}
if (_gameActor.Property.ContainsKey("HurtOtherModify"))
{
skillProp.hurtOtherModify = ((int)_gameActor["HurtOtherModify"]) * 0.0001f;
}
else
{
skillProp.hurtOtherModify = 0.0f;
}
//属性修正aaa
int attAttr = (int)_state["byDamegePro"];
if (attAttr == 0)
{
skillProp.type = SkillType.Skill_Physic;
}
else if (attAttr == 1)
{
skillProp.type = SkillType.Skill_Ice;
}
else if (attAttr == 2)
{
skillProp.type = SkillType.Skill_Fire;
}
else if (attAttr == 3)
{
skillProp.type = SkillType.Skill_Poison;
}
else if (attAttr == 4)
{
skillProp.type = SkillType.Skill_Thunder;
}
skillProp.PropertyModify = CalulatePropertyModify(_gameActor, attAttr);
///体型修正aaaa
skillProp.BodyTypeModify = CalulateBodyModify(_state, targetActor);
//控制状态修正aaa
skillProp.StateModify = CalulateStateModify(_gameActor, targetActor);
SkillDefProperty defProp = new SkillDefProperty();
defProp.level = (int)recProp["Level"];
defProp.def = (int)recProp["Def"];
int dodge = (int)recProp["Dodge"];
defProp.dodgeRate = dodge * fPropertyScale;
defProp.dodgeRate += ((int)recProp["DodgePer"]) * 0.0001f;
defProp.fireDef = (int)recProp["FireDef"];
defProp.iceDef = (int)recProp["IceDef"];
defProp.poisonDef = (int)recProp["PoisonDef"];
int criDmgDef = (int)recProp["CriDmgDef"];
defProp.superDef = (float)criDmgDef * 0.0001f;
defProp.thunderDef = (int)recProp["ThunderDef"];
int flex = (int)recProp["Flex"];
defProp.toughness = (float)flex * fPropertyScale;
if (recProp.ContainsKey("BeHurtModify"))
{
defProp.beHurtModify = ((int)recProp["BeHurtModify"]) * 0.0001f;
}
else
{
defProp.beHurtModify = 0.0f;
}
bool isNormalAtk = false;
if (attAttr == 0)
{
isNormalAtk = true;
}
bool isSuper;
bool bDodge;
dr.damage = CalculateAttack(skillProp, defProp, isNormalAtk, bySkillEffect, out isSuper, out bDodge);
CalculateBubbleType(_state, _gameActor, targetActor, isSuper, bDodge, ref dr);
if (bySkillEffect == HeaderProto.ESkillEffect.SKILL_EFFECT_CURE_HP)
{
targetActor.AddHP(dr.damage);
}
else if (bySkillEffect == HeaderProto.ESkillEffect.SKILL_EFFECT_CURE_MP)
{
targetActor.AddSP(dr.damage);
}
else if (bySkillEffect == HeaderProto.ESkillEffect.SKILL_EFFECT_DAMAGE_SP)
{
targetActor.AddSP(-dr.damage);
}
else
{
if (targetActor.CheckDebuffState(HeaderProto.ECreatureActionState.CREATURE_ACTION_STATE_UNBEAT))
{
dr.bubbleType = Bubble.BubbleType.eBT_Dodge;
dr.damage = 0;
}
targetActor.OnHurt(dr);
}
if (_state.Contains("WeaponHitType"))
{
targetActor.DoHittedAudio((string)_state["WeaponHitType"]);
}
if (targetActor.actorType == ActorType.AT_Monster && dr.damage > 0)
{
sdGameMonster monster = (sdGameMonster)targetActor;
int monsterType = (int)monster.Property["BodyType"];
if (_state.Contains("ParentID") && _state.Contains("dwTemplateID")) //临时代码判断是技能伤害aa
{
int id = (int)_state["dwTemplateID"];
_gameActor.OnAttackRestore(id, dr.damage, monsterType);
}
}
//是否打断被击目标的某些buffer
if (_state.ContainsKey("BreakState"))
{
int[] buffID = (int[])(_state["BreakState"]);
if (buffID.Length == 2)
{
targetActor.RemoveBuff(buffID[0], buffID[1]);
}
}
return(dr);
}
void Start()
{
playerA = GameObject.Find("pSummonerA").transform;
playerB = GameObject.Find("pSummonerB").transform;
property = transform.GetComponent <SkillProperty>();
}
private static object TryConvertValue(Type fieldType, object currentValue, object value)
{
if (value == null)
{
return(null);
}
Type type = value.GetType();
if (fieldType == typeof(GameObject))
{
if (type.IsSubclassOf(typeof(Component)))
{
return(((Component)value).get_gameObject());
}
}
else
{
if (fieldType == typeof(SkillGameObject))
{
if (type == typeof(GameObject))
{
return(new SkillGameObject(value as GameObject));
}
if (type.IsSubclassOf(typeof(Component)))
{
return(new SkillGameObject(((Component)value).get_gameObject()));
}
}
else
{
if (fieldType == typeof(SkillOwnerDefault))
{
if (type == typeof(GameObject))
{
SkillOwnerDefault fsmOwnerDefault = new SkillOwnerDefault();
fsmOwnerDefault.set_OwnerOption(1);
fsmOwnerDefault.set_GameObject(value as GameObject);
return(fsmOwnerDefault);
}
if (type.IsSubclassOf(typeof(Component)))
{
GameObject gameObject = ((Component)value).get_gameObject();
if (gameObject != SkillEditor.SelectedFsmGameObject)
{
SkillOwnerDefault fsmOwnerDefault2 = new SkillOwnerDefault();
fsmOwnerDefault2.set_OwnerOption(1);
fsmOwnerDefault2.set_GameObject(gameObject);
return(fsmOwnerDefault2);
}
return(new SkillOwnerDefault());
}
}
else
{
if (fieldType == typeof(SkillProperty))
{
SkillProperty fsmProperty = currentValue as SkillProperty;
SkillProperty fsmProperty2 = new SkillProperty();
SkillProperty arg_14D_0 = fsmProperty2;
SkillObject fsmObject = new SkillObject();
fsmObject.set_Value(value as Object);
arg_14D_0.TargetObject = fsmObject;
fsmProperty2.setProperty = (fsmProperty != null && fsmProperty.setProperty);
return(fsmProperty2);
}
if (fieldType == typeof(SkillObject))
{
SkillObject fsmObject2 = new SkillObject();
fsmObject2.set_Value(value as Object);
return(fsmObject2);
}
if (fieldType == typeof(SkillMaterial))
{
SkillMaterial fsmMaterial = new SkillMaterial();
fsmMaterial.set_Value(value as Material);
return(fsmMaterial);
}
if (fieldType == typeof(SkillTexture))
{
SkillTexture fsmTexture = new SkillTexture();
fsmTexture.set_Value(value as Texture);
return(fsmTexture);
}
if (fieldType == typeof(SkillEventTarget))
{
if (type == typeof(PlayMakerFSM))
{
return(new SkillEventTarget
{
target = 3,
fsmComponent = value as PlayMakerFSM
});
}
if (type == typeof(GameObject))
{
SkillEventTarget fsmEventTarget = new SkillEventTarget();
fsmEventTarget.target = 1;
SkillEventTarget arg_253_0 = fsmEventTarget;
SkillOwnerDefault fsmOwnerDefault3 = new SkillOwnerDefault();
fsmOwnerDefault3.set_OwnerOption(1);
fsmOwnerDefault3.set_GameObject(value as GameObject);
arg_253_0.gameObject = fsmOwnerDefault3;
return(fsmEventTarget);
}
}
else
{
if (fieldType == typeof(SkillString))
{
if (type == typeof(PlayMakerFSM))
{
SkillString fsmString = new SkillString();
fsmString.set_Value(((PlayMakerFSM)value).get_FsmName());
return(fsmString);
}
if (type == typeof(AnimationClip))
{
SkillString fsmString2 = new SkillString();
fsmString2.set_Value(((AnimationClip)value).get_name());
return(fsmString2);
}
}
}
}
}
}
return(value);
}
public void SkillDamage( SkillProperty _Attacker , SkillProperty _Defender )
{
Debug.Log( "SkillDamage()" ) ;
if( null == _Attacker ||
null == _Defender )
{
return ;
}
// attacker 的 attack property 會被 defender 的 defense property 抵銷
Debug.Log( "_Attacker.AttackProperty=" + _Attacker.AttackProperty.CreatePropertyString() ) ;
Debug.Log( "_Defender.DefenseProperty=" + _Defender.DefenseProperty.CreatePropertyString() ) ;
string [] keys = _Attacker.AttackProperty.GetKeys() ;
for( int i = 0 ; i < keys.Length ; ++i )
{
int attackPower = _Attacker.AttackProperty.GetProperty( keys[ 0 ] ) ;
Debug.Log( "attackPower" + attackPower ) ;
int attckPowerRemain =
_Defender.DefenseProperty.AddPropertyToArmor( keys[ 0 ] , -attackPower ) ;
Debug.Log( "attckPowerRemain" + attckPowerRemain ) ;
_Attacker.AttackProperty.AssignProperty( keys[ 0 ] , attckPowerRemain ) ;
Debug.Log( "_Attacker.AttackProperty for " + keys[ 0 ] + " = " + _Attacker.AttackProperty.GetProperty( keys[ 0 ] ) ) ;
Debug.Log( "_Defender.DefenseProperty for " + keys[ 0 ] + " = " + _Defender.DefenseProperty.GetProperty( keys[ 0 ] ) ) ;
}
}
public UICommands GetFirstCommand(Transform chess)
{
UICommands uiCmds = UICommands.none;
CharacterProperty chessProperty = chess.GetComponent <CharacterProperty>();
if (chessProperty.Summoner)
{
if (MapHelper.Attackable(chess))
{
if (KillAble(chess, 0, chessProperty.Damage))
{
uiCmds = UICommands.Attack;
}
else
{
uiCmds = UICommands.Defense;
}
}
else
{
uiCmds = UICommands.Move;
Transform map = GetMoveTarget(chess);
if (map == null)
{
uiCmds = UICommands.Defense;
}
}
}
else
{
if (MapHelper.Attackable(chess))
{
if (KillAble(chess, 0, chessProperty.Damage) || KillAble(chess, 1, 0))
{
uiCmds = UICommands.Attack;
}
else
{
uiCmds = UICommands.none;
}
}
else
{
uiCmds = UICommands.Move;
}
if (uiCmds == UICommands.none)
{
Transform[] skills = chess.GetComponent <SkillSets>().Skills;
foreach (Transform skill in skills)
{
if (currentSelect.player.GetComponent <ManaCounter>().Mana >= skill.GetComponent <SkillProperty>().SkillCost)
{
SkillProperty skillProperty = skill.GetComponent <SkillProperty>();
if (skillProperty.SType == SkillType.EnhanceSelf && skillProperty.Mode == PowerType.Damage)
{
int newDamage = chessProperty.Damage + skillProperty.ModeValue;
if (KillAble(chess, 0, newDamage))
{
uiCmds = UICommands.Skill;
}
else
{
uiCmds = UICommands.Move;
}
}
else
{
uiCmds = UICommands.Move;
}
}
else
{
uiCmds = UICommands.Move;
}
}
}
}
return(uiCmds);
}
void Start()
{
playerA = GameObject.Find("pSummonerA").transform;
playerB = GameObject.Find("pSummonerB").transform;
property = transform.GetComponent<SkillProperty>();
}
public UICommands GetSecondCommand(Transform chess)
{
UICommands uiCmds = UICommands.none;
CharacterProperty chessP = chess.GetComponent <CharacterProperty>();
AIMoveStore chessAI = new AIMoveStore(chess);
if (chessAI.CmdsUsed.Count <= 1)
{
if (chessP.Summoner)
{
if (chessAI.CmdsLeft.Contains(UICommands.Attack) && MapHelper.Attackable(chess))
{
if (KillAble(chess, 0, chessP.Damage))
{
uiCmds = UICommands.Attack;
}
else if (chessAI.CmdsLeft.Contains(UICommands.Defense))
{
uiCmds = UICommands.Defense;
}
}
else if (chessAI.CmdsUsed.Contains(UICommands.Move))
{
uiCmds = UICommands.Defense;
}
else if (chessAI.CmdsUsed.Contains(UICommands.Defense))
{
//check if summonable
Transform summonGF = GetSummonGF(chess);
Transform summonPos = GetSummonPosition(chess);
if (summonGF != null && summonPos != null)
{
uiCmds = UICommands.Summon;
}
}
}
else
{
if (MapHelper.Attackable(chess))
{
if (KillAble(chess, 0, chessP.Damage) || KillAble(chess, 1, 0))
{
if (chessAI.CmdsLeft.Contains(UICommands.Attack))
{
uiCmds = UICommands.Attack;
}
}
else
{
Transform[] skills = chess.GetComponent <SkillSets>().Skills;
foreach (Transform skill in skills)
{
if (currentSelect.player.GetComponent <ManaCounter>().Mana >= skill.GetComponent <SkillProperty>().SkillCost)
{
SkillProperty skillProperty = skill.GetComponent <SkillProperty>();
if (skillProperty.SType == SkillType.EnhanceSelf && skillProperty.Mode == PowerType.Damage)
{
int newDamage = chessP.Damage + skillProperty.ModeValue;
if (KillAble(chess, 0, newDamage) && chessAI.CmdsLeft.Contains(UICommands.Skill))
{
uiCmds = UICommands.Skill;
}
else if (chessAI.CmdsLeft.Contains(UICommands.Move))
{
uiCmds = UICommands.Move;
}
}
else if (chessAI.CmdsLeft.Contains(UICommands.Move))
{
uiCmds = UICommands.Move;
}
}
else if (chessAI.CmdsLeft.Contains(UICommands.Move))
{
uiCmds = UICommands.Move;
}
}
}
}
}
}
else
{
print("what a f**k, it's not second move");
}
return(uiCmds);
}
public Skill()
{
this.property = new SkillProperty();
this.property.OnChanged += this._OnAttrChanged;
}
