public void UpdateUI(Skill_Info p_info)
{
string ablitystr = ReturnTypeString.GetAblityString(p_info.ablity_type); // 타입 보내서 해당 능력 가져오기
m_SkillName.text = string.Format("{0}", p_info.skill_name); // 이름
m_AblityType.text = ablitystr; // 능력
m_SkillCost.text = string.Format("활력 {0}", p_info.skill_cost); // 스킬 소모량
// 시전 시간
if (p_info.skill_casttime == 0f)
{
m_SkillCastT.text = "즉시 시전";
}
else
{
m_SkillCastT.text = string.Format("시전 시간 {0}초", p_info.skill_casttime);
}
// 사거리
if (p_info.skill_range == 0f)
{
m_SkillRange.text = "유효거리(자신)";
}
else
{
m_SkillRange.text = string.Format("유효거리 0~{0}m", p_info.skill_range);
}
m_SkillDelayT.text = string.Format("{0}초 후 재사용 가능", p_info.skill_delaytime); // 쿨타임
m_SkillRequirePoint.text = string.Format("배우기 요구 조건[{0}] 능력 {1}레벨", ablitystr, p_info.skill_level_requirements); // 조건
m_SkillDescription.text = string.Format("{0}", p_info.skill_description); // 스킬 설명
}
public void AnalyseSkillKouKa(Skill_Info skill, List <ChessContainer> scope_list)
{
//分析效果
switch (skill.my_Kouka)
{
case eSkill_Kouka.DirectDamage:
foreach (ChessContainer cc in scope_list)
{
if (cc.my_chess != null)
{
Chess chess = cc.my_chess;
//伤害计算
DamageInfo _info = new DamageInfo(attribute.GetSklDmg(skill));
int damage = get_attack();
_info.setActor(this);
_info.setPartner(null);
//伤害表现
damage_and_Display(chess, _info);
}
}
break;
case eSkill_Kouka.Cure:
foreach (ChessContainer cc in scope_list)
{
if (cc.my_chess != null)
{
Chess chess = cc.my_chess;
//伤害计算
DamageInfo _info = new DamageInfo(attribute.GetSklDmg(skill));
int damage = get_attack();
_info.setActor(this);
_info.setPartner(null);
//伤害表现
cure_and_Display(chess, _info);
}
}
break;
case eSkill_Kouka.Buff:
foreach (ChessContainer cc in scope_list)
{
if (cc.my_chess != null)
{
foreach (int buff_id in skill.my_buffs)
{
cc.my_chess.AddBuff(new BuffAdder(belong, buff_id));
}
}
}
break;
default:
Debug.Log("错误 08021337 ，技能效果类型未实现。技能ID:" + skill.id);
break;
}
}
// CSV 데이터 로드 (매개 변수로 파일 이름을 받아 데이터 베이스에 로드)
public void CSVDataLoad(string p_file)
{
m_Data = CSVReader.Read(p_file);
for (int i = 0; i < m_Data.Count; i++)
{
Skill_Info info = new Skill_Info();
// 데이터 파싱해서 할당
info.skill_index = int.Parse(m_Data[i]["스킬 번호"].ToString());
info.ablity_type = (E_AblityType)Enum.Parse(typeof(E_AblityType), m_Data[i]["능력"].ToString());
info.skill_type = (E_SkillType)Enum.Parse(typeof(E_SkillType), m_Data[i]["스킬 타입"].ToString());
info.skill_name = m_Data[i]["스킬명"].ToString();
info.skill_cost = int.Parse(m_Data[i]["마나 소모량"].ToString());
info.skill_range = float.Parse(m_Data[i]["사거리"].ToString());
info.skill_delaytime = float.Parse(m_Data[i]["쿨타임"].ToString());
info.skill_casttime = float.Parse(m_Data[i]["시전 시간"].ToString());
info.skill_description = m_Data[i]["스킬 설명"].ToString();
info.skill_point_requirements = int.Parse(m_Data[i]["요구 강화 포인트"].ToString());
info.skill_level_requirements = int.Parse(m_Data[i]["요구 능력 레벨"].ToString());
info.skill_IS_enabled = bool.Parse(m_Data[i]["스킬 활성화 상태"].ToString());
string path = String.Format("Sprite/{0}", info.ablity_type); // 이미지 경로(능력 별로 나눠둠)
m_SpriteArr = Resources.LoadAll <Sprite>(path); // 이미지 로드해서 배열에 저장
info.skill_sprite = m_SpriteArr[i];
m_Skill_List.Add(info); // 리스트에 저장
//Debug.LogFormat(
// "스킬 번호 : {0}" +
// "능력 : {1}\n" +
// "스킬 타입 : {2}\n" +
// "스킬명 : {3}\n" +
// "마나 소모량 : {4}\n" +
// "사거리 : {5}\n" +
// "쿨타임 : {6}\n" +
// "시전 시간 : {7}\n" +
// "스킬 설명 : {8}\n" +
// "요구 강화 포인트 : {9}\n" +
// "요구 능력 레벨 : {10}\n" +
// "스킬 활성화 상태 : {11}\n",
// m_Data[i]["스킬 번호"],
// m_Data[i]["능력"],
// m_Data[i]["스킬 타입"],
// m_Data[i]["스킬명"],
// m_Data[i]["마나 소모량"],
// m_Data[i]["사거리"],
// m_Data[i]["쿨타임"],
// m_Data[i]["시전 시간"],
// m_Data[i]["스킬 설명"],
// m_Data[i]["요구 강화 포인트"],
// m_Data[i]["요구 능력 레벨"],
// m_Data[i]["스킬 활성화 상태"]);
}
}
// 스킬 데이터 배열의 index번째 스킬 배열 반환
public static Skill_Info[] GetSkillDataArr(int p_index)
{
Skill_Info[] ret_info = new Skill_Info[m_SkillDataArr.GetLength(1)];
for (int i = 0; i < ret_info.Length; i++)
{
ret_info[i] = m_SkillDataArr[p_index, i];
}
return(ret_info);
}
public int GetSklDmg(Skill_Info skill)
{
if (skill.skill_damage == -1)
{
return(Pow);
}
else
{
return(skill.skill_damage);
}
}
public void UpdateUI(Skill_Info p_info)
{
string ablitystr = ReturnTypeString.GetAblityString(p_info.ablity_type); // 타입 보내서 해당 능력 가져오기
m_SkillName.text = string.Format("{0}", p_info.skill_name); // 이름
m_AblityType.text = ablitystr; // 능력
m_SkillDescription.text = string.Format("{0}", p_info.skill_description); // 스킬 설명
m_SkillRequirePoint.text = string.Format("배우기 요구 조건[{0}] 강화 포인트 {1} 이상", ablitystr, p_info.skill_point_requirements);
}
// 저장해둔 스킬셋을 로드하여 화면을 재구성
public void ReLoadWindow()
{
// 로드 전에 열려있던 창들 정리
for (int i = 0; i < m_Ablity_ObjArr.Length; i++) // 능력창 개수
{
GameObject skillset = m_Ablity_ObjArr[i].transform.GetChild(0).gameObject; // 각 능력창의 스킬창
for (int j = 0; j < (int)E_SkillType.Max; j++)
{
m_SkillManager.Destroy_Skill_List(skillset.transform.Find("스킬창").GetChild(j), i); // 스킬 매니저로 보내서 삭제
}
skillset.SetActive(false); // 스킬창 비활성화
m_Ablity_SelectBtnArr[i].SetActive(true); // 버튼 활성화
m_Ablity_TypeArr[i] = E_AblityType.None; // 해당 능력창 타입 초기화
}
// 가져온 로드 파일 세팅
for (int i = 0; i < m_SkillSetAll.GetLength(0); i++)
{
if (m_SkillSetAll[i, 0] == null) // 능력 선택 하지 않은 능력창
{
continue;
}
int count = 0; // 활성화 스킬 개수
Skill_Info[] tempinfo = new Skill_Info[m_SkillSetAll.GetLength(1)]; // 2차원 배열에 있는값 1차원 배열로 정리
for (int j = 0; j < m_SkillSetAll.GetLength(1); j++)
{
tempinfo[j] = m_SkillSetAll[i, j];
if (tempinfo[j].skill_type == E_SkillType.Active &&
tempinfo[j].skill_IS_enabled) // 저장된 스킬이 활성화 상태면 카운트 +1
{
count++;
}
}
GameObject skillset = m_Ablity_ObjArr[i].transform.GetChild(0).gameObject; // 각 능력창의 스킬창
for (int k = 0; k < (int)E_SkillType.Max; k++)
{
m_SkillManager.Set_Skill(skillset.transform.Find("스킬창").GetChild(k), i, tempinfo); // 1차원 배열 스킬매니저로 보내서 세팅
}
SkillValue.s_Skill_CountArr[i] = count; // 사용 포인트 설정
SkillValue.s_Remaing_Point -= SkillValue.s_Skill_CountArr[i]; // 남은 포인트에서 제거
m_SkillManager.UpdateUI(); // UI 업데이트
m_Ablity_ObjArr[i].transform.GetChild(0).gameObject.SetActive(true); // 스킬창 활성화
m_Ablity_SelectBtnArr[i].SetActive(false); // 버튼 비활성화
}
}
public void Ritual_Display(Skill_Info skill)
{
switch (skill.my_Type)
{
case eSkill_Type.Ritual:
//GameObject obj = (GameObject)GameObject.Instantiate(Resources.Load("Prefabs/FX/coat_ef"));
BK_AnimEvts obj = BKTools.addVFX_Dancer(PrefabPath.VFX_Ritual);
if (obj)
{
obj.transform.SetParent(transform, false);
}
break;
default:
break;
}
}
public bool Check_Skill_Condition(Skill_Info skill)
{
#if UNITY_EDITOR
if (Main.Inst.is_taboo_skill)
{
return(false);
}
#endif
switch (skill.my_Condition)
{
case eSkill_Condition.None:
return(true);
default:
return(false);
}
}
public float CG_Display(Skill_Info skill)
{
BKTools.addVFX_Dancer(PrefabPath.VFX_CG_Display + skill.cg_display + ".prefab");
return(1.5f);
switch (skill.id)
{
case 10001:
GameObject.Instantiate(Resources.Load("Prefabs/SkillDisplay/Gunfire_ef"));
return(1.5f);
case 10004:
//GameObject.Instantiate(Resources.Load("Prefabs/SkillDisplay/CG_ef_001"));
BKTools.addVFX_Dancer("Assets/Res/Prefabs/SkillDisplay/CG_ef_001");
return(1.5f);
default:
return(0);
}
}
// 패시브 스킬은 엑티브 스킬 일정 개수 찍으면 자동으로 활성화
void UpdatePassiveSkill(int p_index)
{
// 요구 포인트 범위(최소,최대)를 벗어나면 반환
if (SkillValue.s_Skill_CountArr[p_index] < SkillValue.s_Min_RequirePoint ||
SkillValue.s_Skill_CountArr[p_index] > SkillValue.s_Max_RequirePoint)
{
return;
}
// (스킬을 배운 스킬셋 위치의) 패시브 스킬 데이터 가져오기
Skill_Info[] info = new Skill_Info[SkillManager.GetSkillDataLength(p_index)];
info = SkillManager.GetSkillDataArr(p_index);
for (int i = 0; i < info.Length; i++)
{
if (SkillValue.s_Skill_CountArr[p_index] == info[i].skill_point_requirements)
{
info[i].skill_IS_enabled = true;
break;
}
}
}
public Skill_Info[,] JsonLoadData(Skill_Info[,] p_infoarr, string p_string)
{
string tempstr = File.ReadAllText(Application.streamingAssetsPath + "/SaveData/" + p_string + ".json");
m_LoadDataList = JsonUtility.FromJson <JsonData>(tempstr); // 해당 파일 데이터 가져오기
Skill_Info[,] ret_arr = new Skill_Info[p_infoarr.GetLength(0), p_infoarr.GetLength(1)]; // 반환 해줄 데이터
for (int i = 0; i < p_infoarr.GetLength(0); i++)
{
for (int j = 0; j < p_infoarr.GetLength(1); j++)
{
if (m_LoadDataList.J_Data[i].Data[j].skill_sprite == null) // 헤더? 를 읽어 들여 null값이 아닌 값이 들어옴 그래서 스프라이트를 기준으로 빈창인지 체크함
{
break;
}
ret_arr[i, j] = m_LoadDataList.J_Data[i].Data[j]; // 로드한 정보 할당
// Debug.Log(m_LoadDataList.J_Data[i].Data[j].skill_name);
}
}
Debug.LogFormat("{0}.json 로드!!", p_string);
return(ret_arr);
}
/// <summary>
/// Ops the by skill.
/// </summary>
/// <param name="op_list">Op list.</param>
/// <param name="skill">Skill.</param>
/// <param name="dir_limit">Dir limit.</param>
/// <param name="simGrid">假定棋子站在这里发起攻击.</param>
public void OpBySkill(ref List <Operation> op_list, Skill_Info skill, eDirection dir_limit, ChessContainer simGrid)
{
List <ChessContainer> attack_grids = BKTools.GetSkillScope(skill, simGrid);
//筛选攻击目标
//有效性筛选
for (int i = attack_grids.Count - 1; i >= 0; i--)
{
ChessContainer cc = (ChessContainer)attack_grids[i];
if (cc.my_chess == null || !BKTools.IsTargetFit(skill.my_TargetBelong, cc.my_chess.belong, my_chess.belong))
{
attack_grids.RemoveAt(i);
continue;
}
}
//数量筛选
//目标数量有限时，选择合适的目标（大部分时候为随机）
//TODO 这边的随机选择也是不严谨的， [!]注意operation中的目标不会被用于生成ToDoListItem，不影响实际执行
if (skill.target_number != 0)
{
List <ChessContainer> list_copy = new List <ChessContainer>();
foreach (var item in attack_grids)
{
list_copy.Add(item);
}
attack_grids.Clear();
for (int i = 0; i < skill.target_number && list_copy.Count > 0; i++)
{
int index = UnityEngine.Random.Range(0, list_copy.Count);
attack_grids.Add(list_copy[index]);
list_copy.Remove(list_copy[index]);
}
}
Operation op = new Operation();
op.targetGridIndex = simGrid.number;
op.direcion = dir_limit;
op.skill_id = skill.id;
op.skill = skill;
op.attack_target.AddRange(
from grid in attack_grids
// where grid.my_chess != null
select grid.my_chess);
foreach (var target in attack_grids)
{
//评估行动价值
if (skill.skill_damage > target.my_chess.attribute.mana)
{
op.iWouldKillTarget++;
}
// else
// op.iWouldKillTarget = false;
op.bMayBeKilled = false;
op.exDamage += my_chess.attribute.GetSklDmg(skill);
// TODO 此处使用了非正式的受伤判断，可能要很久很久的将来才能补正
op.exInjure = target.my_chess.attribute.Pow;
}
op_list.Add(op);
}
static void AnalyseSkillData(Data inst, ArrayList list)
{
//Data.Inst.skill_data.Add()
string[] str = ((string)list[0]).Split(',');
// foreach (string _s in str) {
// Debug.Log(_s);
// }
for (int x = 1; x < list.Count; x++)
{
Skill_Info info = new Skill_Info();
str = ((string)list[x]).Split(',');
//保险
if (str.Length != (int)eCSV_Skill.Max)
{
continue;
}
info.id = BKTools.ParseInt(str[(int)eCSV_Skill.ID]);
info.name = str[(int)eCSV_Skill.Name];
info.my_Type = (eSkill_Type)BKTools.ParseInt(str[(int)eCSV_Skill.Type]);
info.describe = str[(int)eCSV_Skill.描述];
info.my_Condition = (eSkill_Condition)BKTools.ParseInt(str[(int)eCSV_Skill.COD]);
//info.表格中的隐藏列，没什么卵用 = str[(int)eCSV_Skill.COR];
info.my_Event = (eSkill_Event)BKTools.ParseInt(str[(int)eCSV_Skill.EVT]);
info.my_Locator = (eSkill_Scope_Locator)BKTools.ParseInt(str[(int)eCSV_Skill.STT]);
//定位坐标
string[] location = str[(int)eCSV_Skill.UPS].Split(';');
int coo_x = 0;
foreach (string _num in location)
{
int num = BKTools.ParseInt(_num);
switch (coo_x++)
{
case 0:
info.my_location.x = num;
break;
case 1:
info.my_location.y = num;
break;
case 2:
info.my_location.z = num;
break;
}
}
//定位方式
string[] scopes = str[(int)eCSV_Skill.EXS].Split(';');
info.my_Scope = new eSkill_Scope[scopes.Length];
for (int i = 0; i < scopes.Length; i++)
{
info.my_Scope[i] = (eSkill_Scope)BKTools.ParseInt(scopes[i]);
}
info.my_Scope_Depth = BKTools.ParseInt(str[(int)eCSV_Skill.SCO]);
info.target_number = BKTools.ParseInt(str[(int)eCSV_Skill.TAGnum]);
info.my_select_Solution = (eSkill_Target_SelectSolution)BKTools.ParseInt(str[(int)eCSV_Skill.TAG]);
info.my_TargetBelong = (eSkill_TargetBelong)BKTools.ParseInt(str[(int)eCSV_Skill.TAGtype]);
info.skill_damage = BKTools.ParseInt(str[(int)eCSV_Skill.DAM]);
info.my_Kouka = (eSkill_Kouka)BKTools.ParseInt(str[(int)eCSV_Skill.DAMtype]);
string[] buffs = str[(int)eCSV_Skill.BuffId].Split(';');
info.my_buffs = new int[buffs.Length];
for (int i = 0; i < buffs.Length; i++)
{
info.my_buffs[i] = BKTools.ParseInt(buffs[i]);
}
info.cg_display = str[(int)eCSV_Skill.CG_Display];
int count = Data.Inst.skill_data.Count;
inst.skill_data.Add(info.id, info);
}
}
IEnumerator SkillCoroutine(Skill_Info skill)
{
Main.Inst.addDancer(STR_Skill_Coroutine[0]);
driving_skill_list.Add(this);
//技能发动提示
Ritual_Display(skill);
yield return(new WaitForSeconds(1));
//播放表现
float delay = CG_Display(skill);
yield return(new WaitUntil(BKTools.ISCWithArgu(STR_Skill_Coroutine)));
//ArrayList scope_list = getSkillScope(skill);
List <ChessContainer> scope_list = BKTools.GetSkillScope(skill, container, attack_Direction);
//展示攻击范围
for (int i = scope_list.Count - 1; i >= 0; i--)
{
ChessContainer cc = (ChessContainer)scope_list[i];
BK_AnimEvts vfx = BKTools.addVFX_Dancer(Main.Inst.GetComponent <VFX_Dictionary>().Skill_Scope_Mark);
vfx.transform.SetParent(cc.transform, false);
}
yield return(new WaitUntil(BKTools.ISCWithArgu(STR_Skill_Coroutine)));
//筛选攻击目标
//有效性筛选
for (int i = scope_list.Count - 1; i >= 0; i--)
{
ChessContainer cc = (ChessContainer)scope_list[i];
if (cc.my_chess == null || !BKTools.IsTargetFit(skill.my_TargetBelong, cc.my_chess.belong, belong))
{
scope_list.RemoveAt(i);
continue;
}
}
//目标数量有限时，选择合适的目标（大部分时候为随机）
//info.target_number
if (skill.target_number != 0)
{
List <ChessContainer> list_copy = new List <ChessContainer>();
foreach (var item in scope_list)
{
list_copy.Add(item);
}
scope_list.Clear();
for (int i = 0; i < skill.target_number && list_copy.Count > 0; i++)
{
int index = UnityEngine.Random.Range(0, list_copy.Count);
scope_list.Add(list_copy[index]);
list_copy.Remove(list_copy[index]);
}
}
//展示攻击目标
for (int i = scope_list.Count - 1; i >= 0; i--)
{
ChessContainer cc = (ChessContainer)scope_list[i];
BK_AnimEvts vfx = BKTools.addVFX_Dancer(Main.Inst.GetComponent <VFX_Dictionary>().Skill_Target_Mark);
vfx.transform.SetParent(cc.transform, false);
}
yield return(new WaitUntil(BKTools.ISCWithArgu(STR_Skill_Coroutine)));
//计算效果
Main.Inst.b_attacked = true;
AnalyseSkillKouKa(skill, scope_list);
//计算结果后等待
yield return(new WaitForSeconds(Data.DELAY_AFTER_SKILL));
driving_skill_list.Remove(this);
attack_Direction = eDirection.All;
Main.Inst.redDancer(STR_Skill_Coroutine[0]);
yield return(null);
}
//================================================
//技能相关
public void SkillStart(Skill_Info skill)
{
StartCoroutine(SkillCoroutine(skill));
}
