public override BaseCharacter Init(int groupHandle, float agentDensity, Stat baseStat, BaseState idle, BaseState attack, BaseState move, BaseState death, BaseState chase = null)
{
base.Init(groupHandle, agentDensity, baseStat, idle, attack, move, death, chase);
m_skill = GetComponent <BaseSkill>().Init(this);
return(this);
}
protected void UseSkill(string id, Vector3?aimPosition)
{
BaseSkill skill = null;
short skillLevel = 0;
if (!GameInstance.Skills.TryGetValue(BaseGameData.MakeDataId(id), out skill) || skill == null ||
!PlayerCharacterEntity.GetCaches().Skills.TryGetValue(skill, out skillLevel))
{
return;
}
bool isAttackSkill = skill.IsAttack();
if (!aimPosition.HasValue)
{
if (PlayerCharacterEntity.RequestUseSkill(skill.DataId, isLeftHandAttacking) && isAttackSkill)
{
// Requested to use attack skill then change attacking hand
isLeftHandAttacking = !isLeftHandAttacking;
}
}
else
{
if (PlayerCharacterEntity.RequestUseSkill(skill.DataId, isLeftHandAttacking, aimPosition.Value) && isAttackSkill)
{
// Requested to use attack skill then change attacking hand
isLeftHandAttacking = !isLeftHandAttacking;
}
}
}
private void ReceivedDamage_PvpGetGold(
Vector3 fromPosition,
IGameEntity attacker,
CombatAmountType combatAmountType,
int damage,
CharacterItem weapon,
BaseSkill skill,
short skillLevel)
{
if (!IsServer)
{
return;
}
if (attacker == null || attacker.Entity == Entity || !(attacker.Entity is BasePlayerCharacterEntity))
{
return;
}
if (!this.IsDead())
{
return;
}
int rewardGold = 100;
(attacker.Entity as BasePlayerCharacterEntity).RewardCurrencies(new Reward()
{
gold = rewardGold
}, 1f, RewardGivenType.None);
}
/// <summary>
/// 回复卡牌
/// </summary>
/// <returns></returns>
public BaseSkill getRecoverSkill(int number)
{
//还要消耗栏
UseSkill cardEffect1 = (sender, args) =>
{
BaseRoleAction baseRole = (BaseRoleAction)sender;
if (baseRole.GetMp() >= number)
{
baseRole.SetMp(baseRole.GetMp() - number);
return(new ReturnDTO(RETURN_CODE.SUCCESS));
}
else
{ //打断
Console.WriteLine("法力值不足");
return(new ReturnDTO(RETURN_CODE.BATTLE_HAS_NO_MP));
}
};
UseSkill cardEffect2 = (sender, args) =>
{
BaseRoleAction baseRole = ((BaseRoleAction)sender);
//TODO 让target受到伤害。反射判断target有没有受伤害都脚本
// baseRole.attacked();的动画
baseRole.SetHp(baseRole.GetHp() + number);
return(new ReturnDTO(RETURN_CODE.SUCCESS));
};
BaseSkill card = new BaseSkill(2, "回复术", "", 1, 1, 1, false, number, null,
"没有什么是钱解决不了的问题", new UseSkill[] { cardEffect1, cardEffect2 });
card.IsAvailable = true;
return(card);
}
public void MulTakeEnemy()
{
if (Skillinfo != null)
{
MultiSkill ss = Skillinfo as MultiSkill;
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
bool isCollider = Physics.Raycast(ray, out hitInfo);
if (isCollider)
{
if (hitInfo.collider.tag == Tags.ground)
{
if (Vector3.Distance(transform.position, hitInfo.point) < ss.SkillDis)
{
PlayerStatusManager.Instance.CutMP(Skillinfo.SkillMP);
Vector3 vector3 = new Vector3(hitInfo.point.x, hitInfo.point.y + 1, hitInfo.point.z);
GameObject effect = Resources.Load <GameObject>(Skillinfo.EffectPath);
effect = Instantiate(effect, vector3, hitInfo.transform.rotation);
effect.GetComponent <MulSkillEffect>().Init(Skillinfo);
transform.LookAt(hitInfo.point);
PlayerState = AnimationStates.SkillAttack;
PlayAnim(ss.AnimName, ss.AnimTime, () => { PlayerState = AnimationStates.Attack; });
}
}
}
}
isLockPosition = false;
Skillinfo = null;
MouseCursorManager.Instance.SetMouseCorsor(MouseCursorTypes.Normal);
}
public void Modify(BaseSkill skill)
{
skillName.Value = skill.SkillName;
imagePath.Value = skill.IconPath;
longDescription.Value = skill.LongDescription;
shortDescription.Value = skill.ShortDescription;
targetDescription.Value = skill.TargetDescription;
skillLevel.Value = skill.SkillLevel.ToString();
nextLevel.Value = skill.NextLevelNeedHeroLevel.ToString();
if (skill is ActiveSkill)
{
// 主动技能的情况下
ActiveSkill activeSkill = skill as ActiveSkill;
hotKey.Value = activeSkill.KeyCode.ToString();
mp.Value = activeSkill.Mp.ToString();
CD.Value = activeSkill.CD.ToString();
spellDistance.Value = activeSkill.SpellDistance.ToString();
}
else
{
// 被动技能的情况下
PassiveSkill passiveSkill = skill as PassiveSkill;
hotKey.Value = "";
mp.Value = "";
CD.Value = "";
spellDistance.Value = "";
}
}
void InitSkill()
{
skills = new List <BaseSkill>();
// 普攻技能
attackSkill = SkillFactory.GetSkillByID(cardData.normolAttID, this);
BaseSkill skill = null;
if (cardData.skill1ID > 0)
{
skill = SkillFactory.GetSkillByID(cardData.skill1ID, this, cardData.GetSkillPara(1));
skills.Add(skill);
}
if (cardData.skill2ID > 0)
{
skill = SkillFactory.GetSkillByID(cardData.skill2ID, this, cardData.GetSkillPara(2));
skills.Add(skill);
}
if (cardData.skill3ID > 0)
{
skill = SkillFactory.GetSkillByID(cardData.skill3ID, this, cardData.GetSkillPara(2));
skills.Add(skill);
}
}
public virtual void Play(Transform model, BaseSkill skillSetting, BaseCharacterBehavior toTarget = null)
{
this.skillSetting = skillSetting;
this.model = model;
costTimer = Time.time;
SkillStart();
if (playingTime < animate.Sum(a => a.length))
{
playingTime = animate.Sum(a => a.length);
}
foreach (AnimationClip anim in animate)
{
if (model.GetComponent <Animation>() != null)
{
model.GetComponent <Animation>()[anim.name].layer = 6;
model.GetComponent <Animation>()[anim.name].AddMixingTransform(transform);
model.GetComponent <Animation>().PlayQueued(anim.name);
}
}
if (!Movable)
{
user.IsSkilling = true;
}
}
public int SchoolEffectsForSkill(BaseSkill skill)
{
float modifier = 1f;
// Check for same school bonus and apply if there
for (int i = 0; i < skill.Owner.GetComponent <BaseCharacter> ().Schools.Count; i++)
{
if (Information.Name == skill.Owner.GetComponent <BaseCharacter> ().Schools[i].Information.Name)
{
modifier += skill.Owner.GetComponent <BaseCharacter> ().Stats.SameSchoolBonus;
}
}
// Check if there are boosts or negative boosts to be applies based on skill vs opponent
for (int i = 0; i < skill.Target.GetComponent <BaseCharacter> ().Schools.Count; i++)
{
if (StrongAgainst == skill.Target.GetComponent <BaseCharacter> ().Schools [i].Information.Name)
{
modifier += StrongPercent;
}
if (WeakAgainst == skill.Target.GetComponent <BaseCharacter> ().Schools [i].Information.Name)
{
modifier += WeakPercent;
}
}
int rounded = (int)Mathf.Floor(modifier * skill.Power);
return(rounded);
}
/// <summary>
/// 初始化函数,加载文件路径
/// </summary>
public void Init()
{
PlayerStatusManager.Instance.LvUP += StartUpdateUI;
List <BaseSkill> SkillInfoList = new List <BaseSkill>();
SkillItemList = new List <SkillListItem>();
string sql = "select * from skill_information";
DataTable dt = MysqlHelper.ExecuteTable(sql, CommandType.Text, null);
foreach (DataRow item in dt.Rows)
{
Type type = Type.GetType(item["skill_type"].ToString());
object[] parameters = new object[1];
parameters[0] = item;
object obj = Activator.CreateInstance(type, parameters);
BaseSkill bs = obj as BaseSkill;
SkillInfoList.Add(bs);
}
for (int i = 0; i < SkillInfoList.Count; i++)
{
if (SkillInfoList[i].PlayerType == PlayerStatusManager.Instance.playerInfo.PlayerType)
{
SkillListItem si = (SkillListItem)UIPackage.CreateObject("SkillMenu", "SkillListItem");
si.SkillInfo = SkillInfoList[i];
si.SetValues();
SkillItemList.Add(si);
}
}
}
public void TakeEnemy()
{
if (Skillinfo != null)
{
SingleSkill ss = Skillinfo as SingleSkill;
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
bool isCollider = Physics.Raycast(ray, out hitInfo);
if (isCollider)
{
if (hitInfo.collider.tag == Tags.enemy)
{
if (Vector3.Distance(transform.position, hitInfo.transform.position) < ss.SkillDis)
{
PlayerStatusManager.Instance.CutMP(Skillinfo.SkillMP);
agent.SetDestination(transform.position);
PlayerState = AnimationStates.SkillAttack;
PlayAnim(ss.AnimName, ss.AnimTime, () => { PlayerState = AnimationStates.Attack; });
isEnemy = true;
transform.LookAt(hitInfo.transform);
GameObject effect = Resources.Load <GameObject>(ss.EffectPath);
GameObject.Instantiate(effect, hitInfo.transform.position, Quaternion.identity);
hitInfo.collider.SendMessage("GetAttack", ss.SkillDamage);
}
}
}
}
isLockTarget = false;
Skillinfo = null;
MouseCursorManager.Instance.SetMouseCorsor(MouseCursorTypes.Normal);
}
private void createFilteredList(string search)
{
//generate objects to be layed out in the panel
List <GameObject> knownSkills = SkillLibrary.Instance.getByListID(PlayerMotivator.Instance.getSkillBook());
skillList = new List <GameObject>();
OrderEnum pri = PlayerMotivator.Instance.GetPrimaryOrderEnum();
OrderEnum sec = PlayerMotivator.Instance.GetSecondaryOrderEnum();
foreach (GameObject skill in knownSkills)
{
BaseSkill component = skill.GetComponent <BaseSkill>();
// make sure that it has a baseSkill component, just in case
if (component != null)
{
OrderEnum skillOrder = component.getOrder();
// and check if the object is of the right order, then add it to the list
if (skillOrder == pri || skillOrder == sec || skillOrder == OrderEnum.none)
{
// Gets the name and searches it for any instances of the search string
if (component.getName().ToLower().Contains(search.ToLower()))
{
skillList.Add(skill);
}
}
}
}
}
void Atk()
{
state = AtkState.atkend;
parent.SetAnimatorState(InGameBaseCharacter.AnimatorState.Idle, 1);
BaseSkill.CreateSkill(parent.GetBaseSkillID(), parent, (InGameBaseCharacter)target);
//((InGameBaseCharacter)target).ChangeLife(-parent.GetAtkForce());
}
public override void Play(Transform model, BaseSkill skillSetting, BaseCharacterBehavior toTarget = null)
{
this.toTarget = toTarget;
healingMount = skillSetting.AdjustedDamage * user.status.GetSecondaryAttrubute(SecondaryAttributeName.MagicalDamage).AdjustedValue *user.status.GetStaticAttribute(StaticAttributeName.HealMake).AdjustedValue;
base.Play(model, skillSetting, toTarget);
}
private void ReceivedDamage_PvpGetGold(
Vector3 fromPosition,
IGameEntity attacker,
CombatAmountType combatAmountType,
int damage,
CharacterItem weapon,
BaseSkill skill,
short skillLevel)
{
if (!IsServer)
{
return;
}
if (attacker == null || attacker.Entity == Entity || !(attacker.Entity is BasePlayerCharacterEntity))
{
return;
}
int rewardGold = 100;
BasePlayerCharacterEntity character = (attacker.Entity as BasePlayerCharacterEntity);
if (!this.IsDead())
{
return;
}
character.Gold = character.Gold.Increase(rewardGold);
GameInstance.ServerGameMessageHandlers.NotifyRewardGold(character.ConnectionId, rewardGold);
}
void Atk()
{
state = ActionState.atkend;
parent.SetAnimatorState(InGameBaseCharacter.AnimatorState.Idle, 1);
if (target != null)
{
if (GameConst.CAMP_ATK[(int)target.camp, (int)parent.camp] == 0)
{
if (target.GetObjType() == InGameBaseObj.enObjType.map)
{
InGameBaseMapObj mapobj = (InGameBaseMapObj)target;
bool isdie = mapobj.Hurt(parent);
if (isdie)
{
state = ActionState.non;
return;
}
}
}
else
{
BaseSkill.CreateSkill(parent.GetBaseSkillID(), parent, (InGameBaseCharacter)target);
}
}
//((InGameBaseCharacter)target).ChangeLife(-parent.GetAtkForce());
}
public override void RegisterCard(CardFighter card)
{
base.RegisterCard(card);
skill = SkillFactory.GetSkillByID(param1, card, new int[] { param2 });
card.AddEventListener(BattleEventType.ON_CARD_PRESENT, OnPresent);
}
public override void Play(Transform model, BaseSkill skillSetting, BaseCharacterBehavior castTo = null)
{
base.Play(model, skillSetting);
if (user is NPCController)
{
Vector3 targetPos = (user as NPCController).attackTarget.position + (user as NPCController).attackTarget.GetComponent <CharacterController>().center;
float dis = Vector3.ProjectOnPlane(targetPos - user.transform.position, Vector3.up).magnitude;
//Debug.Log(targetPos);
//水平速度固定計算出飛行時間,飛行時間+重力計算出垂直速度
var speedZ = startSpeed;
// T = dX / (startSpeedX )
// y = -_gravity / 2 * t * t + a * t + c;
// v = -2gt + a
// a = (y-c)/t + g/2*t
flyTime = dis / speedZ;
var speedY = (targetPos.y - transform.position.y) / flyTime + _gravity / 2 * flyTime;;
Vector3 sp = new Vector3(0, speedY, speedZ);
//轉軸 速度方向成為水平平面,改變起使速度為算出來的速度量
_ps.transform.localRotation = Quaternion.LookRotation(sp);
_ps.startSpeed = sp.magnitude;
}
else
{
flyTime = _ps.startLifetime;
}
destroyTimer = Time.time;
}
public Freeze(BaseSkill s)
: base(new BaseObjectInformation(name, description))
{
this.PrimaryStat = "speed";
this.PrimaryAmount = 0.8f;
this.Skill = s;
}
private void InitObject(
LevelObjectView obj,
ObjectTypeInfo objectTypeInfo,
ObjectProtoInfo objectProtoInfo,
SpawnLocation spawnLocation,
LevelSettings levelSettings)
{
obj.transform.rotation =
Quaternion.Euler(0f, spawnLocation.IsXFlipped ? 180f : 0f, 0f);
var alternating = obj.GetComponent <AlternatingView>();
if (alternating != null)
{
int materialIndex = UnityEngine.Random.Range(
0, objectProtoInfo.AvailableMaterials.Length);
alternating.Material =
objectProtoInfo.AvailableMaterials[materialIndex];
}
if (objectTypeInfo.Type == playerObjectType)
{
List <int> skillIds = playerStateStorage.Get().SkillIds;
for (int i = 0; i < skillIds.Count; ++i)
{
Skill skill = skillStorage.Get(skillIds[i]);
BaseSkill baseSkill = skillStorage.GetBase(skill.BaseId);
ISkillHelper skillHelper =
skillHelperStorage.Get(baseSkill.Type);
skillHelper.AddSkill(skill, obj.gameObject);
}
}
}
public virtual void Init(BaseSkill baseSkill)
{
this.name = baseSkill.name;
AnimationStateName = baseSkill.AnimationStateName;
SkillIcon = baseSkill.SkillIcon;
MinRangeValue = baseSkill.MinRangeValue;
MaxRangeValue = baseSkill.MaxRangeValue;
SkillMode = baseSkill.SkillMode;
DamageType = baseSkill.DamageType;
DamageMultiple = baseSkill.DamageMultiple;
TargetType = baseSkill.TargetType;
AOEValue = baseSkill.AOEValue;
IsIgnoreSelf = baseSkill.IsIgnoreSelf;
SkillDuration = baseSkill.SkillDuration;
TurnCD = baseSkill.TurnCD;
MoveToTarget = baseSkill.MoveToTarget;
CurrentCD = 0;
Description = baseSkill.Description;
IsSelfOnly = baseSkill.IsSelfOnly;
IsAppendDamageOnRoute = baseSkill.IsAppendDamageOnRoute;
EffectsReceiver = baseSkill.EffectsReceiver;
EffectOnHit = baseSkill.EffectOnHit;
EffectOnSelf = baseSkill.EffectOnSelf;
EffectOnTarget = baseSkill.EffectOnTarget;
}
public void Update()
{
//교준, 은기, 건희 셋중
//if (GameManager.Instance.GAME_OVER)
// return;
foreach (KeyValuePair <BaseObject, List <BaseSkill> > pair
in DicUseSkill)
{
List <BaseSkill> list = pair.Value;
for (int i = 0; i < list.Count; i++)
{
BaseSkill updateSkill = list[i];
updateSkill.UpdateSkill();
if (updateSkill.END)
{
list.Remove(updateSkill);
Destroy(updateSkill.gameObject);
}
}
}
////추가 170622 am10:13
//if (makeSkill != null)
//{
// makeSkill.transform.position = parentTransform.position;
// makeSkill.transform.rotation = parentTransform.rotation;
// //
//}
}
private Dictionary <int, List <Tuple <BaseSkill, float> > > GetSoldierMosTrainingBySoldierTemplateId(
IDbConnection connection, Dictionary <int, BaseSkill> baseSkillMap)
{
Dictionary <int, List <Tuple <BaseSkill, float> > > soldierTemplateMosMap =
new Dictionary <int, List <Tuple <BaseSkill, float> > >();
IDbCommand command = connection.CreateCommand();
command.CommandText = "SELECT * FROM SoldierMosTraining";
var reader = command.ExecuteReader();
while (reader.Read())
{
int soldierTemplateId = reader.GetInt32(0);
int baseSkillId = reader.GetInt32(1);
float points = (float)reader[2];
BaseSkill baseSkill = baseSkillMap[baseSkillId];
Tuple <BaseSkill, float> training = new Tuple <BaseSkill, float>(baseSkill, points);
if (!soldierTemplateMosMap.ContainsKey(soldierTemplateId))
{
soldierTemplateMosMap[soldierTemplateId] = new List <Tuple <BaseSkill, float> >();
}
soldierTemplateMosMap[soldierTemplateId].Add(training);
}
return(soldierTemplateMosMap);
}
private void SkillEvent(BaseSkill skill)
{
if (OnSkill != null)
{
OnSkill(skill);
}
}
public void TestLoadSkillData()
{
string skillJson = Resources.Load <TextAsset>("Data/TestData").text;
skillJson = Regex.Replace(skillJson, " |\n|\t", "");
Debug.Log(skillJson);
// 获得在JSON数据中的技能列表数据
JsonData skillJsonList = JsonMapper.ToObject(skillJson);
Debug.Log("skillData:" + skillJsonList.ToJson());
foreach (JsonData skillData in skillJsonList)
{
// 根据skilltype获取对应技能类
Type SkillClass = Type.GetType(skillData["SkillType"].ToString());
Debug.Log(skillData["SkillType"].ToString());
// 根据skillType技能类型与泛型方法进行合并，生成最终的方法
MethodInfo methodInfo = GenericMethod.MakeGenericMethod(SkillClass);
// 执行该泛型函数
BaseSkill skill = methodInfo.Invoke(null, new object[] { skillData }) as BaseSkill;
baseSkillDataSet.Add(skill);
}
}
private void UpdateSkillIcons()
{
UIUtils.SetVisibility(TextNoSkill.gameObject, PlayerRef.SkillCount == 0);
BaseSkill data = PlayerRef.SkillData;
UIUtils.SetVisibility(ImgSkill.gameObject, data != null);
if (data != null)
{
ImgSkill.SetImage(data.spriteRes);
}
if (mSkillIconVisibleCount != (byte)PlayerRef.SkillCount)
{
mSkillIconVisibleCount = (byte)PlayerRef.SkillCount;
for (int i = mSkillIcons.Count; i >= 1; --i)
{
UIUtils.SetVisibility(mSkillIcons[i - 1], i <= PlayerRef.SkillCount);
}
}
else
{
return;
}
}
public void replaceSkill(int index, GameObject newSkill)
{
BaseSkill skill = newSkill.GetComponent <BaseSkill>();
GameObject ToBeDestroyed = skillBar[index];
if (skill != null)
{
foreach (GameObject s in skillBar)
{
if (s != null)
{
BaseSkill t = s.GetComponent <BaseSkill>();
if (t != null)
{
if (t.getID() == skill.getID())
{
// replaceSkill(System.Array.IndexOf(skillBar, s), ToBeDestroyed);
int switchIndex = System.Array.IndexOf(skillBar, s);
Destroy(skillBar[switchIndex]);
placeSkill(switchIndex, ToBeDestroyed);
// instead, call the place function twice
}
}
}
}
}
placeSkill(index, newSkill);
// seperate this into a function
if (ToBeDestroyed != null)
{
Debug.Log("Destroying: " + ToBeDestroyed.name);
Destroy(ToBeDestroyed);
}
}
protected void notifyTargettedSubscribers(ObjectInteractable source, BaseSkill skill)
{
foreach (var observer in targettedObservers)
{
observer.trigger((source, skill));
}
}
public override ActionInfo DoAction()
{
_opponents = null;
if (!baseSkills.Any())
{
return new ActionInfo
{
time = 0f
}
}
;
var skill = currentSkill = baseSkills.FirstOrDefault();
if (skill == null || skill is Object && skill.Equals(null))
{
return new ActionInfo
{
time = 0f
}
}
;
_opponents = skill.DetermineOpponents();
// Execute the skill
skill.Execute(animator, _baseCharacter, _opponents[0]);
return(new ActionInfo
{
time = skill.GetLength()
});
}
public SkillIconItem(Transform Parent, BaseSkill Skill, RectTransform CancelObj, bool IsRect /*temp*/)
{
this.Skill = Skill;
IconTransform = AssetManager.CreatePrefabSync(new AssetUri(IsRect ? "prefabs/skillicon.prefab" : "prefabs/newskillIcon.prefab")).transform;
IconTransform.SetParent(Parent, false);
UIHelper.GetComponent <Image>(IconTransform, "BG/Icon").sprite = AssetManager.CreateAssetSync <Sprite>(new AssetUri(Skill.Icon));
UIHelper.GetComponent <Image>(IconTransform, "BG/Mask").sprite = AssetManager.CreateAssetSync <Sprite>(new AssetUri(Skill.Icon));
Mask_ = IconTransform.Find("BG/Mask").GetComponent <Image>();
Mask_.fillAmount = 1;
CDText_ = IconTransform.Find("CD").GetComponent <Text>();
CDText_.gameObject.SetActive(false);
NameText_ = IconTransform.Find("Name").GetComponent <Text>();
NameText_.text = Skill.Name;
Selector_ = SkillLibrary.Get(Skill.SkillID).Selector.Clone();
var Args = new SkillArgs(Skill)
{
CancelObj = CancelObj
};
Selector_.BindCarrier(IconTransform, Args, (SArgs) =>
{
Skill.Master.Skill.UseSkill(SArgs);
});
}
public void OnDespawned()
{
masterArmor = null;
masterAISkill = null;
status = null;
pool = null;
this.rigidbody.velocity = Vector3.zero;
}
public virtual void Initialise(BaseSkill skill)
{
ownerSkill = skill;
currentNumberOfTargets = 0;
IgnoreOwnCollisions();
//Invoke("IgnoreOwnCollisions", 2f);
if(!isProjectile)
{
//myFunction = Deactivate;
//InvokeNextFrame(myFunction);
}
else
Activate();
}
/**
* Load from Xml
* */
void Load()
{
TextAsset textAsset = (TextAsset) Resources.Load("Entities/"+definition);
if (!textAsset) Debug.Log("failed to load xml resource");
var doc = new XmlDocument();
doc.LoadXml (textAsset.text);
XmlNodeList entity = doc.SelectNodes ("entity");
var atlist = entity.Item(0).Attributes.GetNamedItem("attrib").Value.Split(' ');
int count = 0;
foreach (string atr in atlist) {
attrib[count] = new BaseAttrib();
attrib[count].baseValue = int.Parse(atr);
count++;
}
level = int.Parse (entity.Item (0).Attributes.GetNamedItem ("level").Value);
profession = entity.Item (0).Attributes.GetNamedItem ("class").Value;
XmlNodeList myskills = doc.SelectNodes ("entity/skills/skill");
foreach (XmlNode node in myskills) {
//Debug.Log("skill "+node.Attributes.GetNamedItem("id").Value);
BaseSkill s = new BaseSkill();
s.Name = node.Attributes.GetNamedItem("id").Value;
s.baseValue = int.Parse(node.Attributes.GetNamedItem("level").Value);
skills.Add(s);
}
XmlNodeList myabilities = doc.SelectNodes ("entity/skills/abilities");
foreach (XmlNode node in myabilities) {
//Debug.Log("skill "+node.Attributes.GetNamedItem("id").Value);
BaseAbility a = new BaseAbility();
a.Name = node.Attributes.GetNamedItem("id").Value;
abilities.Add(a);
}
XmlNodeList myitems = doc.SelectNodes ("entity/inventory/item");
foreach (XmlNode node in myitems) {
//Debug.Log("item "+node.Attributes.GetNamedItem("id").Value);
var item = GameInstance.ItFactory.CreateItem(node.Attributes.GetNamedItem("id").Value);
int idx = UnityEngine.Random.Range(100,90000);
if (inventory.ContainsKey(idx))
idx = UnityEngine.Random.Range(90000,200000);
inventory[idx] = item;
}
}
public void Activate(BaseSkill skill){
info.SetActive(true);
info.transform.position = new Vector2((Input.mousePosition.x + 200), (Input.mousePosition.y - 75));
if(skillTitle != null){
skillTitle.enabled = true;
skillTitle.text = skill.name;
}else {
skillTitle.enabled = false;
}
if (skillDescription != null){
skillDescription.enabled = true;
skillDescription.text = skill.description;
}else{
skillDescription.enabled = false;
}
}
// Use this for initialization
void Start()
{
speed = new BaseSkill ("Speed");
attack = new BaseSkill ("Attack");
jump = new BaseSkill ("Jump");
}
public void AddSkillToggle(GameObject parentObject, BaseSkill skill)
{
GameObject newToggle = (GameObject)Instantiate(skillTogglePrefab);
newToggle.transform.SetParent(parentObject.transform);
Text toggleText = newToggle.GetComponentInChildren<Text>();
toggleText.text = skill.SkillName;
Toggle toggleObj = newToggle.GetComponent<Toggle>();
toggleObj.onValueChanged.AddListener((bool toggled) =>
{
if (toggled)
{
if (parentObject == careerSkillsLayout)
{
skill.InitialCareerBoost = true;
skill.MinSkillRank++;
numCareerSkills--;
if (numCareerSkills == 0)
{
DisableRemainderToggles(parentObject);
}
}
else if(parentObject == careerBonusSkillsLayout)
{
skill.InitialBonusBoost = true;
skill.MinSkillRank++;
numBonusSkills--;
if (numBonusSkills == 0)
{
DisableRemainderToggles(parentObject);
}
}
skill.SkillRank++;
Debug.Log("Set " + skill.SkillName + " to Rank " + skill.SkillRank);
}
else
{
if (parentObject == careerSkillsLayout)
{
skill.InitialCareerBoost = false;
skill.MinSkillRank--;
numCareerSkills++;
EnableToggles(parentObject);
}
else if (parentObject == careerBonusSkillsLayout)
{
skill.InitialBonusBoost = false;
skill.MinSkillRank--;
numBonusSkills++;
EnableToggles(parentObject);
}
skill.SkillRank--;
Debug.Log("Set " + skill.SkillName + " to Rank " + skill.SkillRank);
}
skill.SkillRank = skill.MinSkillRank;
SetNumberCareerSkills(numCareerSkills);
SetNumberBonusSkills(numBonusSkills);
});
}
public int CalculateStat(BaseEotESpecies species, BaseEotECareer carreer, BaseSkill.SkillCharacteristic characteristic)
{
int baseStat = 0;
switch (characteristic)
{
case BaseSkill.SkillCharacteristic.BRAWN:
baseStat = species.MinBrawn;
break;
case BaseSkill.SkillCharacteristic.AGILITY:
baseStat = species.MinAgility;
break;
case BaseSkill.SkillCharacteristic.INTELLECT:
baseStat = species.MinIntellect;
break;
case BaseSkill.SkillCharacteristic.CUNNING:
baseStat = species.MinCunning;
break;
case BaseSkill.SkillCharacteristic.WILLPOWER:
baseStat = species.MinWillpower;
break;
case BaseSkill.SkillCharacteristic.PRESENCE:
baseStat = species.MinPresence;
break;
default:
break;
}
return baseStat;
}
void RemoveSkillRank(BaseSkill skill)
{
int rankCost = 0;
if (skill.IsCareerSkill || skill.IsCareerBonusSkill)
{
rankCost = 5 * (skill.SkillRank);
}
else
{
rankCost = 10 * (skill.SkillRank);
}
if (skill.SkillRank > skill.MinSkillRank)
{
CharacterInformation.CurrentAvailXP += rankCost;
CharacterInformation.TotalXP -= rankCost;
SetXP();
skill.SkillRank--;
}
else
{
Debug.Log("Cannot lower " + skill.SkillName + " lower than its combined species/career minimum.");
}
}
void AddSkillRank(BaseSkill skill)
{
int rankCost = 0;
if (skill.IsCareerSkill || skill.IsCareerBonusSkill)
{
rankCost = 5 * (skill.SkillRank + 1);
}
else
{
rankCost = 10 * (skill.SkillRank + 1);
}
if ((skill.SkillRank + 1) < 3)
{
if (CharacterInformation.CurrentAvailXP >= rankCost)
{
CharacterInformation.CurrentAvailXP -= rankCost;
CharacterInformation.TotalXP += rankCost;
SetXP();
skill.SkillRank++;
}
else
{
Debug.Log("Not enough XP to increase rank.");
}
}
else
{
Debug.Log("Cannot exceed Skill Rank 2 in initial character build.");
}
}
void SetSkillRank(Image image, BaseSkill skill)
{
switch (skill.SkillRank)
{
case 1:
image.sprite = Resources.Load<Sprite>("Textures/Skill/Rank/SkillRanks1");
break;
case 2:
image.sprite = Resources.Load<Sprite>("Textures/Skill/Rank/SkillRanks2");
break;
case 3:
image.sprite = Resources.Load<Sprite>("Textures/Skill/Rank/SkillRanks3");
break;
case 4:
image.sprite = Resources.Load<Sprite>("Textures/Skill/Rank/SkillRanks4");
break;
case 5:
image.sprite = Resources.Load<Sprite>("Textures/Skill/Rank/SkillRanks5");
break;
default:
image.sprite = Resources.Load<Sprite>("Textures/Skill/Rank/SkillRanksBlank");
break;
}
}
void SetSkillCareerOrBonus(Image image, BaseSkill skill)
{
if (skill.IsCareerSkill)
{
image.sprite = Resources.Load<Sprite>("Textures/Skill/Career/CareerSkill");
if(skill.IsCareerBonusSkill)
{
image.sprite = Resources.Load<Sprite>("Textures/Skill/Career/CareerAndBonusSkill");
}
}
else if(skill.IsCareerBonusSkill)
{
image.sprite = Resources.Load<Sprite>("Textures/Skill/Career/BonusSkill");
}
else
{
image.sprite = Resources.Load<Sprite>("Textures/Skill/Career/NotCareer");
}
}
public void RemoveStatusEffect(BaseSkill ownerSkill)
{
for (int i = statusEffects.Count - 1; i > -1; i--)
{
if(statusEffects[i].ownerSkill == ownerSkill && (statusEffects[i].statusEffect.effectFormat == SkillEffectFormat.useDuration || statusEffects[i].statusEffect.effectFormat == SkillEffectFormat.instant) )
{
statusEffects[i].EndEffect();
}
}
for (int i = speedModifiers.Count - 1; i > -1; i--)
{
if(speedModifiers[i].ownerSkill == ownerSkill && (speedModifiers[i].statusEffect.effectFormat == SkillEffectFormat.useDuration || speedModifiers[i].statusEffect.effectFormat == SkillEffectFormat.instant))
{
speedModifiers[i].EndEffect();
}
}
}
/*public string TranslateSpecialization()
{
return "";
}*/
public string TranslateSkillCategory(BaseSkill.SkillCategory category)
{
string categoryString = "";
switch (category)
{
case BaseSkill.SkillCategory.COMBAT:
categoryString = "Combat";
break;
case BaseSkill.SkillCategory.GENERAL:
categoryString = "General";
break;
case BaseSkill.SkillCategory.KNOWLEDGE:
categoryString = "Knowledge";
break;
default:
Debug.Log("Skill category could not be identified: " + category.ToString());
break;
}
return categoryString;
}
public string TranslateSkillCharacteristic(BaseSkill.SkillCharacteristic characteristic)
{
string characteristicString = "";
switch (characteristic)
{
case BaseSkill.SkillCharacteristic.AGILITY:
characteristicString = "Agility";
break;
case BaseSkill.SkillCharacteristic.BRAWN:
characteristicString = "Brawn";
break;
case BaseSkill.SkillCharacteristic.CUNNING:
characteristicString = "Cunning";
break;
case BaseSkill.SkillCharacteristic.INTELLECT:
characteristicString = "Intellect";
break;
case BaseSkill.SkillCharacteristic.PRESENCE:
characteristicString = "Presence";
break;
case BaseSkill.SkillCharacteristic.WILLPOWER:
characteristicString = "Willpower";
break;
default:
Debug.LogWarning("Skill characteristic could not be identified: " + characteristic.ToString());
break;
}
return characteristicString;
}
public void SetSkill(BaseSkill skillToSet)
{
if (skillToSet.IsCareerSkill)
{
if (skillToSet.IsCareerBonusSkill)
{
careerSkillImage.sprite = careerAndBonusSkillSprite;
}
else
{
careerSkillImage.sprite = careerSkillSprite;
}
}
else if (skillToSet.IsCareerBonusSkill)
{
careerSkillImage.sprite = careerBonusSkillSprite;
}
else
{
careerSkillImage.sprite = notCareerSkillSprite;
}
switch (skillToSet.MinSkillRank)
{
case 1:
skillRankImage.sprite = skillRankOneSprite;
break;
case 2:
skillRankImage.sprite = skillRankTwoSprite;
break;
case 3:
skillRankImage.sprite = skillRankThreeSprite;
break;
case 4:
skillRankImage.sprite = skillRankFourSprite;
break;
case 5:
skillRankImage.sprite = skillRankFiveSprite;
break;
default:
skillRankImage.sprite = skillRankZeroSprite;
break;
}
string skillStatString = "";
switch(skillToSet.SkillStat)
{
case BaseSkill.SkillCharacteristic.AGILITY:
skillStatString = "(Ag)";
break;
case BaseSkill.SkillCharacteristic.BRAWN:
skillStatString = "(Br)";
break;
case BaseSkill.SkillCharacteristic.CUNNING:
skillStatString = "(Cu)";
break;
case BaseSkill.SkillCharacteristic.INTELLECT:
skillStatString = "(Int)";
break;
case BaseSkill.SkillCharacteristic.PRESENCE:
skillStatString = "(Pr)";
break;
case BaseSkill.SkillCharacteristic.WILLPOWER:
skillStatString = "(Will)";
break;
default:
break;
}
//Debug.Log(skillToSet.SkillName);
//Debug.Log(skillStatString);
skillText.text = skillToSet.SkillName + " " + skillStatString;
}
private GameObject setupSlotWithSkill(BaseSkill skill, int slotID) {
GameObject slot = Instantiate (activeSkillUI.skillSlot);
SkillSlot slotScript = slot.GetComponent<SkillSlot> ();
slotScript.skill = skill;
slotScript.slotID = slotID;
Image img = slot.transform.FindChild ("SkillItem").gameObject.GetComponent<Image>();
img.sprite = Resources.Load<Sprite> (GameConstants.spritePath + skill.imageName);
Text skillKey = img.transform.FindChild ("Key").gameObject.GetComponent<Text> ();
skillKey.text = (slotID + 1).ToString();
Text cooldown = img.transform.FindChild ("Cooldown").gameObject.GetComponent<Text> ();
cooldown.text = "";
skillDictionary.Add (skill.identifier, slotID + 1);
return slot;
}
private GameObject setupSlotWithSkill(BaseSkill skill, int slotID) {
GameObject slot = Instantiate (skillSlot);
SkillSlot slotScript = slot.GetComponent<SkillSlot> ();
slotScript.skill = skill;
slotScript.slotID = slotID;
Image img = slot.transform.FindChild ("SkillItem").gameObject.GetComponent<Image>();
img.sprite = Resources.Load<Sprite> (GameConstants.spritePath + skill.imageName);
Text skillText = img.GetComponentInChildren<Text>();
skillText.text = skill.level + " / " + skill.maxLevel;
return slot;
}
private void addSkillSlot(BaseSkill skill, int slotID) {
GameObject slot = setupSlotWithSkill (skill, slotID);
slot.transform.SetParent (activeSkillUI.skillPanel.transform);
skillSlotList.Add (slot);
}
