static void AnalyseCardData(Data inst, ArrayList list)
{
string[] str, str_img;
str_img = new string[list.Count - 1];//头
for (int x = 1; x < list.Count; x++)
{
//新建信息
Card_Info info = new Card_Info();
str = ((string)list[x]).Split(',');
info.id = BKTools.ParseInt(str[(int)eCSV_Card.ID]);
info.name = str[(int)eCSV_Card.NAME];
info.img = str[(int)eCSV_Card.IMG];
str_img[x - 1] = info.img;
info.cost = BKTools.ParseInt(str[(int)eCSV_Card.COST]);
info.spd = BKTools.ParseInt(str[(int)eCSV_Card.SPD]);
info.mana = BKTools.ParseInt(str[(int)eCSV_Card.MANA]);
info.atk = BKTools.ParseInt(str[(int)eCSV_Card.CT]);
info.vct = (eCard_Vocation)BKTools.ParseInt(str[(int)eCSV_Card.VCT]);
info.rare = BKTools.ParseInt(str[(int)eCSV_Card.RARE]);
info.stk = BKTools.ParseInt(str[(int)eCSV_Card.STK]);
info.skill01 = BKTools.ParseInt(str[(int)eCSV_Card.skill01]);
info.skill02 = BKTools.ParseInt(str[(int)eCSV_Card.skill02]);
info.spellcard = BKTools.ParseInt(str[(int)eCSV_Card.spellcard]);
inst.card_data.Add(info.id, info);
}
// 初始化需要完整的卡牌数据
// TODO 也可能只初始化战斗中用到的可拍数据
Card_Info.initSprite();
}
IEnumerator corTDL_Strike(TDL_Item item)
{
CheckStrike(0);
yield return(new WaitUntil(BKTools.ISCWithArgu(item.type.ToString())));
Main.Inst.redDancer(item.type.ToString());
TDL.RemoveAt(0);
yield return(null);
}
static ArrayList fnLoadFile(eResBundle eID, string path)
{
//BKTools.Assetbundle_path + BKTools.Assetbundle_Name_By_Platform + BKTools.bundles_dir[(int)eID]
//var ta = BKTools.getBundle(eID).LoadAsset<TextAsset> (path);
var ta = BKTools.LoadAsset <TextAsset>(eID, path);
var xmlText = ta.text;
ArrayList t_aArrayList = new ArrayList(); // 容器
string[] arrs = xmlText.Split(new string[] { "\r\n", "\n" }, StringSplitOptions.RemoveEmptyEntries);
foreach (string str in arrs)
{
t_aArrayList.Add(str);
}
return(t_aArrayList);
}
/// <summary>
/// TDL技能/攻击 协线程.
/// TDL相关参数需要技能信息、方向限制
/// </summary>
IEnumerator corTDL_Skill(TDL_Item item)
{
if (item.argu_Direction != eDirection.None)
{
attack_Direction = item.argu_Direction;
}
SkillStart(item.argu_skill_info);
// Debug.Log ("技能开始" + Time.time);
yield return(new WaitUntil(BKTools.ISCWithArgu(item.type.ToString())));
// Debug.Log ("技能结束" + Time.time);
Main.Inst.redDancer(item.type.ToString());
TDL.RemoveAt(0);
yield return(null);
}
/// <summary>
/// TDL移动 协线程.
/// TDL相关参数需要移动目的地ID
/// </summary>
/// <returns>The TD l move.</returns>
/// <param name="item">Item.</param>
IEnumerator corTDL_Move(TDL_Item item)
{
Main.Inst.now_turnphase.StartMoveChess(this);
// Debug.Log ("移动开始" + Time.time);
yield return(new WaitForSeconds(GameRule.Moveing_Duration));
Main.Inst.now_turnphase.moveChess(this, Main.Inst.chess_grids[item.argu_grid_id], item.argu_trigger_strike);
// Debug.Log ("移动" + Time.time);
//万一有执行强袭就要等待
yield return(new WaitUntil(BKTools.ISCWithArgu(item.type.ToString())));
// Debug.Log ("移动结束" + Time.time);
Main.Inst.redDancer(item.type.ToString());
TDL.RemoveAt(0);
yield return(null);
}
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 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);
}
}
public void show_movable_area()
{
List <ChessContainer> result_list = new List <ChessContainer>();
//TODO 等BK_Tools中getAroundGrid函数重写后替换
//container.search_around(ref result_list, 0, attribute.spd);
result_list.Add(container);
BKTools.getAroundGrid(attribute.Spd, result_list, true, false, null);
result_list.Remove(container);
#region 清理不在战斗区域的标记
List <ChessContainer> not_in_battle_area = new List <ChessContainer>();
foreach (var item in result_list)
{
if (!Main.Inst.lv_ctrl.AreaBattle.Contains(item.number))
{
not_in_battle_area.Add(item);
}
}
foreach (var grid in not_in_battle_area)
{
result_list.Remove(grid);
}
#endregion
foreach (ChessContainer cc in result_list)
{
if (cc.isMoveBan(owner))
{
continue;
}
//可移动区域-面片色块
GameObject obj = Instantiate(bg_move, cc.transform.position, cc.transform.rotation);
list_movable_area.Add(obj);
cc.setMoveFlag_On();
obj.transform.parent = transform;
Vector3 new_pos = obj.transform.localPosition;
new_pos.z = 0.3f;
obj.transform.localPosition = new_pos;
}
}
/// <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);
}
public List <Operation> generateOperations()
{
Chess c = my_chess;
List <ChessContainer> res_list = new List <ChessContainer> ();
List <ChessContainer> search_list = new List <ChessContainer> ();
search_list.Add(c.container);
search_list = BKTools.getAroundGrid(c.attribute.Spd, search_list);
res_list.Add(c.container);//原地不动也是一种选择
foreach (var item in search_list)
{
//TODO 判断条件需要完善
if (item.my_chess == null && GameRule.judgePassable(c, item))
{
res_list.Add(item);
}
}
//return res_list;
List <Operation> op_list = new List <Operation>();
//检索所有移动选项
foreach (var grid in res_list)
{
foreach (var skill in my_chess.attribute.skill)
{
if (skill == null)
{
continue;
}
//根据攻击生成行动方案
switch (skill.my_select_Solution)
{
case eSkill_Target_SelectSolution.Auto:
//随机攻击型
//按照可能击杀的数量和总体伤害计算
OpBySkill(ref op_list, skill, eDirection.All, grid);
break;
case eSkill_Target_SelectSolution.Human:
//制定攻击目标
//方向限制型
//按照可能击杀的数量和总体伤害计算
//每个方向进行一次选择
for (eDirection i = eDirection.UpperLeft; i < eDirection.All; i++)
{
OpBySkill(ref op_list, skill, i, grid);
}
break;
default:
break;
}
}
// 罗列攻击手段
// 按攻击手段获得每一个格子上能打到的目标
// 根据目标的血量和攻击手段获得攻击性相关行动数据
//
// 对产生的攻击方案，判断对方反击时会造成的伤害预期获得防御相关的行动数据
// ps:上面这个运算需要一个整体的将来战局模拟数据
}
return(op_list);
}
static void AnalyseBuffData(Data inst, ArrayList list)
{
string[] str;
for (int x = 1; x < list.Count; x++)
{
Buff_Info info = new Buff_Info();
str = ((string)list[x]).Split(',');
//保险
if (str.Length != (int)eCSV_Buff.Max)
{
continue;
}
info.id = BKTools.ParseInt(str[(int)eCSV_Buff.ID]);
info.name = str[(int)eCSV_Buff.Name];
info.describe = str[(int)eCSV_Buff.说明];
info.my_event = (eBuffEvent)BKTools.ParseInt(str[(int)eCSV_Buff.事件]);
info.effect = (eBuff_Effect)BKTools.ParseInt(str[(int)eCSV_Buff.Effect]);
//数值
string[] values = str[(int)eCSV_Buff.Value].Split(';');
info.values = BKTools.ParseInt(values);
info.duration = BKTools.ParseInt(str[(int)eCSV_Buff.Round]);
info.my_Locator = (eSkill_Scope_Locator)BKTools.ParseInt(str[(int)eCSV_Buff.起点]);
//定位坐标
string[] location = str[(int)eCSV_Buff.起点参数].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_Buff.范围图形].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_Buff.范围大小]);
info.my_TargetBelong = (eSkill_TargetBelong)BKTools.ParseInt(str[(int)eCSV_Buff.目标类型]);
info.start_vfx = Buff_Info.vfx_buff_dir + str[(int)eCSV_Buff.开始特效];
info.duration_vfx = Buff_Info.vfx_buff_dir + str[(int)eCSV_Buff.持续特效];
inst.buff_data.Add(info.id, info);
}
}
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);
}
//下棋
virtual public Chess setChess(int card_id, ePlayer card_belong, ChessContainer t_grid, BKKZ.POW01.AI.eAI_Type ai_type, bool trigger_shokan_skill, int shoukan_event, int event_sequence)
{
//TODO 后期加入召唤参数，如果是强制召唤才能把当前格子上的骑士顶开
if (t_grid.my_chess != null)
{
t_grid.my_chess.KickAway();
}
//分支 pve玩家召唤时有可能是第二次召唤
bool need_new = true;
long chessid = 0;
if (Main.Inst.lv_ctrl.map_data.my_type == eMapType.PvE_Mult || Main.Inst.lv_ctrl.map_data.my_type == eMapType.PvE_Solo)
{
chessid = Chess.genarateChessID(card_id, (int)card_belong, shoukan_event, event_sequence);
need_new = !Main.Inst.dic_chess.ContainsKey(chessid);
}
Chess the_chess = null;
if (need_new)
{
//创建棋子
the_chess = Instantiate(BKTools.LoadAsset <GameObject>(eResBundle.Prefabs, PrefabPath.Chess)).GetComponent <Chess>();
the_chess.attribute.card_id = card_id;
the_chess.belong = card_belong;
the_chess.owner = card_belong;
the_chess.MouseDown = Main.Inst.MouseDownOnChess;
the_chess.MouseUp = Main.Inst.MouseUpOnChess;
//召唤信息——对应事件——玩家为-1
the_chess.shoukan_event = shoukan_event;
//事件ID确认后可以获得事件序号
the_chess.shoukan_event_sequence = event_sequence;
//初始化数据
the_chess.initData();
//初始化图片
the_chess.initImage();
Main.Inst.dic_chess.Add(the_chess.ChessID, the_chess);
//创建AI
if (card_belong < ePlayer.Player1 || card_belong > ePlayer.Player4)
{
BKKZ.POW01.AI.MonsterAI.createMonsterAI(the_chess.ChessID, ai_type);
}
}
else
{
the_chess = Main.Inst.dic_chess[chessid];
the_chess.gameObject.SetActive(true);
}
t_grid.appendChess(the_chess);
//召唤技能
if (trigger_shokan_skill)
{
the_chess.ShouKanSkillAndPincer();
}
//驱散迷雾
//BKTools.FogLift(newchess.container.number, newchess.attribute.spd + GameRule.Default_PvE_Fog_Lift_Range, GameRule.Default_PvE_Fog_Lift_Range, new int[] { (int)newchess.belong });
// Main.Instance.b_setchess = true;
// Main.Instance.now_phase = ePhase.Battle;
// Main.Instance.b_phase_trigger = true;//从战斗阶段往主要阶段2
// 只有主流会耗卡
if (Main.Inst.now_turnphase.myType == ePhaseType.Main1)
{
UseHandCard();
}
if (Main.Inst.now_turnphase.myType != ePhaseType.Drama)
{
CheckMoveEvent(the_chess, nextPhaseDefault);
}
return(the_chess);
}
