private string setUnitSkillLevel(ref PacketStructUnit _unit, string _skillLevel)
{
if (_unit == null)
{
return("");
}
MasterDataParamChara master = MasterFinder <MasterDataParamChara> .Instance.Find((int)_unit.id);
if (master == null)
{
return("");
}
if (master.skill_limitbreak == 0)
{
return("");
}
MasterDataSkillLimitBreak skillMaster = MasterFinder <MasterDataSkillLimitBreak> .Instance.Find((int)master.skill_limitbreak);
if (skillMaster == null)
{
return("");
}
int skillLevel = _skillLevel.ToInt(0);
if (skillLevel > skillMaster.level_max)
{
skillLevel = skillMaster.level_max;
}
_unit.limitbreak_lv = (uint)skillLevel;
return(skillLevel.ToString());
}
/// <summary>
/// ヒーロースキル設定
/// </summary>
/// <param name="skill_id"></param>
public void setupHeroSkill(uint skill_id, int hero_id = 0, int level = 0, bool is_turn_labal_black = false)
{
MessageBgH = MESSAGE_BG_HEIGHT;
TitleWidth = TITLE_DEFAULT_WIDTH;
TitleBGImage = ResourceManager.Instance.Load("skill_name_bg2", ResourceType.Common);
SkillTitleImage = ResourceManager.Instance.Load("tutorial_select_master", ResourceType.Common);
IsTurnLabelBlackColor = is_turn_labal_black;
IsSkillItem = true;
IsViewIcon = false;
IsViewStatus = false;
SkillTitleY = 0;
if (skill_id != 0)
{
BaseHeight = BASE_DEFAULT_HEIGHT;
TitleHeight = TITLE_DEFAULT_HEIGHT;
IsViewElement = false;
IsViewTurn = true;
IsViewSkillLevel = false;
MasterDataSkillLimitBreak _master = MasterFinder <MasterDataSkillLimitBreak> .Instance.Find((int)skill_id);
if (_master == null)
{
return;
}
SkillTitleText = _master.name;
SkillDetailText = _master.detail;
if (hero_id > 0 && level > 0)
{
MasterDataHeroAddEffectRate _addRate = MasterFinder <MasterDataHeroAddEffectRate> .Instance.SelectWhere("where hero_id = ? and start_level <= ? and ? <= end_level", hero_id, level, level).First();
if (_addRate != null)
{
SkillDetailText += string.Format("\n" + GameTextUtil.GetText("hero_skill_activationrate"), _addRate.additional_effect_value);
}
}
TurnLabel = "";
TurnValue = string.Format(GameTextUtil.GetText("unit_skill3"), (_master.use_turn));
}
else
{
BaseHeight = BASE_DEFAULT_HEIGHT;
TitleHeight = TITLE_DEFAULT_HEIGHT;
IsViewElement = false;
IsViewTurn = false;
IsViewSkillLevel = false;
SkillTitleText = "-";
SkillDetailText = "-";
}
MessageBgResize();
MessageBgResize();
}
/// <summary>
/// このキャラのリミットブレイクターン数
/// </summary>
/// <returns></returns>
public int GetMaxTurn()
{
MasterDataSkillLimitBreak lbsParam = BattleParam.m_MasterDataCache.useSkillLimitBreak(m_CharaMasterDataParam.skill_limitbreak);
if (lbsParam != null)
{
return lbsParam.use_turn - m_CharaLBSLv;
}
return -1;
}
public string getSkillLimitBreakName(uint id)
{
MasterDataSkillLimitBreak master_data = useSkillLimitBreak(id);
if (master_data != null)
{
return(master_data.name);
}
return(null);
}
} //!< スキル汎用領域：
//-------------------------
// データコンバート用領域
//
// マスターデータは配列として持ってこれないので、
// インポートの後にこの領域に変数をまとめて配列化する
//-------------------------
// public int value_turn_min{get;set;} //!< スキル情報コンバート領域：スキル効果ターン：最低
// public int value_turn_max{get;set;} //!< スキル情報コンバート領域：スキル効果ターン：最大
/// <summary>
/// コピー
/// </summary>
/// <param name="cSrc"></param>
public void Copy(MasterDataSkillLimitBreak src)
{
timing_public = src.timing_public;
name = src.name;
detail = src.detail;
add_fix_id = src.add_fix_id;
use_turn = src.use_turn;
use_sp = src.use_sp;
level_max = src.level_max;
level_up_rate = src.level_up_rate;
phase = src.phase;
subject_type = src.subject_type;
subject_value = src.subject_value;
skill_elem = src.skill_elem;
skill_type = src.skill_type;
skill_cate = src.skill_cate;
skill_effect = src.skill_effect;
skill_damage_enable = src.skill_damage_enable;
skill_power = src.skill_power;
skill_power_fix = src.skill_power_fix;
skill_power_hp_rate = src.skill_power_hp_rate;
skill_absorb = src.skill_absorb;
skill_kickback = src.skill_kickback;
skill_kickback_fix = src.skill_kickback_fix;
skill_chk_atk_affinity = src.skill_chk_atk_affinity;
skill_chk_atk_leader = src.skill_chk_atk_leader;
skill_chk_atk_passive = src.skill_chk_atk_passive;
skill_chk_atk_ailment = src.skill_chk_atk_ailment;
skill_chk_def_defence = src.skill_chk_def_defence;
skill_chk_def_ailment = src.skill_chk_def_ailment;
skill_chk_def_barrier = src.skill_chk_def_barrier;
status_ailment_target = src.status_ailment_target;
status_ailment1 = src.status_ailment1;
status_ailment2 = src.status_ailment2;
status_ailment3 = src.status_ailment3;
status_ailment4 = src.status_ailment4;
hate_value = src.hate_value;
value0 = src.value0;
value1 = src.value1;
value2 = src.value2;
value3 = src.value3;
value4 = src.value4;
value5 = src.value5;
value6 = src.value6;
value7 = src.value7;
value8 = src.value8;
value9 = src.value9;
value10 = src.value10;
value11 = src.value11;
value12 = src.value12;
value13 = src.value13;
value14 = src.value14;
value15 = src.value15;
}
/// <summary>
/// アクティブスキル設定
/// </summary>
/// <param name="skill_id"></param>
/// <param name="level"></param>
public void setupLimitBreakSkill(uint skill_id, uint level, bool is_turn_labal_black = false)
{
MessageBgH = MESSAGE_BG_HEIGHT;
TitleWidth = TITLE_DEFAULT_WIDTH;
TitleBGImage = ResourceManager.Instance.Load("skill_name_bg2", ResourceType.Common);
SkillTitleImage = ResourceManager.Instance.Load("ACTIVE", ResourceType.Common);
IsTurnLabelBlackColor = is_turn_labal_black;
IsSkillItem = true;
IsViewIcon = false;
IsViewStatus = false;
if (skill_id != 0)
{
BaseHeight = BASE_DEFAULT_HEIGHT + 12.0f;
TitleHeight = TITLE_DEFAULT_HEIGHT + 12.0f;
SkillTitleY = 6;
IsViewElement = false;
IsViewTurn = true;
IsViewSkillLevel = true;
MasterDataSkillLimitBreak _master = MasterFinder <MasterDataSkillLimitBreak> .Instance.Find((int)skill_id);
if (_master == null)
{
return;
}
SkillTitleText = _master.name;
SkillDetailText = _master.detail;
TurnLabel = "";
TurnValue = string.Format(GameTextUtil.GetText("unit_skill2"), (_master.use_turn - (int)level));
SkillLevelText = string.Format(GameTextUtil.GetText("unit_skill1"), level + 1, _master.level_max + 1);
}
else
{
BaseHeight = BASE_DEFAULT_HEIGHT;
TitleHeight = TITLE_DEFAULT_HEIGHT;
IsViewElement = false;
IsViewTurn = false;
IsViewSkillLevel = false;
SkillTitleText = "-";
SkillDetailText = "-";
}
MessageBgResize();
}
/// <summary>
/// ヒーロースキルを作成（リミットブレイクスキルの一種として動作させてみる）
/// </summary>
public void createHeroSkill()
{
m_RecastTurn = 0;
MasterDataSkillLimitBreak base_skill = BattleParam.m_MasterDataCache.useSkillLimitBreak(m_HeroSkillID);
if (base_skill != null)
{
m_RecastTurn = base_skill.use_turn;
MasterDataSkillLimitBreak hero_skill = new MasterDataSkillLimitBreak(); // 追加効果ありスキル
hero_skill.Copy(base_skill);
MasterDataSkillLimitBreak hero_skill_atk_only = new MasterDataSkillLimitBreak(); // 攻撃のみスキル
hero_skill_atk_only.Copy(hero_skill);
hero_skill.fix_id = HERO_SKILL_ID;
hero_skill_atk_only.fix_id = HERO_SKILL_ATK_ONLY_ID;
if (hero_skill.skill_absorb != 0 ||
hero_skill.skill_kickback != 0 ||
hero_skill.skill_kickback_fix != 0 ||
hero_skill.skill_cate != MasterDataDefineLabel.SkillCategory.NONE
)
{
// 追加効果がある場合
hero_skill.name = hero_skill.name + "+追加効果";
// 攻撃のみスキルの攻撃以外の効果を消す
hero_skill_atk_only.skill_absorb = 0; // 吸血効果
hero_skill_atk_only.skill_kickback = 0; // 反動ダメージ
hero_skill_atk_only.skill_kickback_fix = 0; // 反動ダメージ
hero_skill_atk_only.skill_cate = MasterDataDefineLabel.SkillCategory.NONE;
hero_skill_atk_only.status_ailment1 = 0;
hero_skill_atk_only.status_ailment2 = 0;
hero_skill_atk_only.status_ailment3 = 0;
hero_skill_atk_only.status_ailment4 = 0;
}
BattleParam.m_MasterDataCache.addSkillLimitBreak(hero_skill);
BattleParam.m_MasterDataCache.addSkillLimitBreak(hero_skill_atk_only);
}
}
/**
* プレイヤー側で使用しているマスターデータをキャッシュ.
*/
public void CachePlayerMasterData(CharaParty player_party)
{
clearCachePlayerAll();
// 常駐スキル.
MasterDataSkillActive[] master_data_skill_active_array = null;
#if BUILD_TYPE_DEBUG && USE_DEBUG_JSON_MASTER_DATA
if (BattleParam.m_IsUseDebugJsonMasterData)
{
master_data_skill_active_array = BattleMasterDataFromJson.Instance.getMasterDataAll <MasterDataSkillActive>();
for (int idx = 0; idx < master_data_skill_active_array.Length; idx++)
{
MasterDataSkillActive master_data_skill_active = master_data_skill_active_array[idx];
if (master_data_skill_active.always == MasterDataDefineLabel.BoolType.ENABLE)
{
useSkillActive(master_data_skill_active.fix_id);
}
}
}
else
#endif //USE_DEBUG_JSON_MASTER_DATA
{
MasterDataSkillActive[] resMasterDataSkillActiveArray = MasterFinder <MasterDataSkillActive> .Instance.SelectWhere("where always = ? ", MasterDataDefineLabel.BoolType.ENABLE).ToArray();
if (resMasterDataSkillActiveArray != null)
{
foreach (MasterDataSkillActive resMasterDataSkillActive in resMasterDataSkillActiveArray)
{
useSkillActive(resMasterDataSkillActive.fix_id);
}
}
}
for (int i = 0; i < player_party.getPartyMemberMaxCount(); i++)
{
CharaOnce chara = player_party.getPartyMember((GlobalDefine.PartyCharaIndex)i, CharaParty.CharaCondition.EXIST);
if (chara == null)
{
continue;
}
if (!chara.m_bHasCharaMasterDataParam)
{
continue;
}
// キャラ情報を保存
MasterDataParamChara master_data_param_chara = chara.m_CharaMasterDataParam;
addCharaParam(master_data_param_chara);
// リンクキャラを保存
MasterDataParamChara master_data_param_link_chara = null;
if (chara.m_LinkParam != null)
{
master_data_param_link_chara = useCharaParam(chara.m_LinkParam.m_CharaID);
}
//--------------------------------
// スキル情報を保存 <アクティブ１>
//--------------------------------
{
MasterDataSkillActive master_data_skill_active = useSkillActive(master_data_param_chara.skill_active0);
if (master_data_skill_active != null)
{
useSkillBoost(master_data_skill_active.skill_boost_id);
}
}
//--------------------------------
// スキル情報を保存 <アクティブ２>
//--------------------------------
{
MasterDataSkillActive master_data_skill_active = useSkillActive(master_data_param_chara.skill_active1);
if (master_data_skill_active != null)
{
useSkillBoost(master_data_skill_active.skill_boost_id);
}
}
//--------------------------------
// スキル情報を保存 <リーダー>
//--------------------------------
{
int loop_counter = 0;
MasterDataSkillLeader master_data_skill_leader = useSkillLeader(master_data_param_chara.skill_leader);
while (master_data_skill_leader != null)
{
// 無限ループ検出
if (_checkinfiniteLoop(ref loop_counter))
{
master_data_skill_leader.add_fix_id = 0;
break;
}
master_data_skill_leader = useSkillLeader(master_data_skill_leader.add_fix_id);
}
}
//--------------------------------
// スキル情報を保存 <パッシブ>
//--------------------------------
{
int loop_counter = 0;
MasterDataSkillPassive master_data_skill_passive = useSkillPassive(master_data_param_chara.skill_passive);
while (master_data_skill_passive != null)
{
// 無限ループ検出
if (_checkinfiniteLoop(ref loop_counter))
{
master_data_skill_passive.add_fix_id = 0;
break;
}
master_data_skill_passive = useSkillPassive((uint)master_data_skill_passive.add_fix_id);
}
}
//--------------------------------
// スキル情報を保存 <リンクパッシブ>
//--------------------------------
// バトル中の判定には使わないが、ダイアログの表示に使われるので保存.
useSkillPassive(master_data_param_chara.link_skill_passive);
//--------------------------------
// スキル情報を保存 <リミブレ>
//--------------------------------
{
int loop_counter = 0;
MasterDataSkillLimitBreak master_data_skill_limit_break = useSkillLimitBreak(master_data_param_chara.skill_limitbreak);
while (master_data_skill_limit_break != null)
{
// 無限ループ検出
if (_checkinfiniteLoop(ref loop_counter))
{
master_data_skill_limit_break.add_fix_id = 0;
break;
}
master_data_skill_limit_break = useSkillLimitBreak((uint)master_data_skill_limit_break.add_fix_id);
}
}
//--------------------------------
// スキル情報を保存 <リンク>
//--------------------------------
if (master_data_param_link_chara != null)
{
//--------------------------------
// スキル情報を保存 <リンクスキル>
//--------------------------------
useSkillActive(master_data_param_link_chara.skill_active0);
//--------------------------------
// スキル情報を保存 <リンクパッシブ>
//--------------------------------
{
int loop_counter = 0;
MasterDataSkillPassive master_data_skill_passive = useSkillPassive(master_data_param_link_chara.link_skill_passive);
while (master_data_skill_passive != null)
{
// 無限ループ検出
if (_checkinfiniteLoop(ref loop_counter))
{
master_data_skill_passive.add_fix_id = 0;
break;
}
master_data_skill_passive = useSkillPassive((uint)master_data_skill_passive.add_fix_id);
}
}
}
}
}
public void addSkillLimitBreak(MasterDataSkillLimitBreak master_data_skill_limit_break)
{
m_SkillLimitBreak.add(master_data_skill_limit_break);
}
/// <summary>
/// ヒーロースキルのスキルアクティビティを取得
/// </summary>
/// <returns></returns>
public BattleSkillActivity getHeroSkillActivity()
{
//--------------------------------
// 追加効果の有無
//--------------------------------
uint hero_skill_id = HERO_SKILL_ATK_ONLY_ID;
if (BattleSceneUtil.checkChancePercentSkill(getAdditionalEffectPercent()))
{
hero_skill_id = HERO_SKILL_ID;
DebugBattleLog.writeText(DebugBattleLog.StrOpe + "主人公スキル追加効果：あり(追加効果発動確率:" + getAdditionalEffectPercent().ToString() + "%)");
}
else
{
DebugBattleLog.writeText(DebugBattleLog.StrOpe + "主人公スキル追加効果：なし(追加効果発動確率:" + getAdditionalEffectPercent().ToString() + "%)");
}
MasterDataSkillLimitBreak param = BattleParam.m_MasterDataCache.useSkillLimitBreak(hero_skill_id);
if (param == null)
{
return(null);
}
//--------------------------------
// スキル発動情報
//--------------------------------
BattleSkillActivity activity = new BattleSkillActivity();
activity.m_SkillParamOwnerNum = GlobalDefine.PartyCharaIndex.HERO;
activity.m_SkillParamFieldID = InGameDefine.SELECT_NONE;
activity.m_SkillParamSkillID = hero_skill_id;
activity.m_Effect = param.skill_effect;
activity.m_Type = param.skill_type;
activity.m_Element = param.skill_elem;
activity.m_SkillType = ESKILLTYPE.eLIMITBREAK;
activity.m_Category_SkillCategory_PROPERTY = param.skill_cate;
activity.m_SkillParamTarget = null;
activity.m_skill_power = param.skill_power;
activity.m_skill_power_fix = param.skill_power_fix;
activity.m_skill_power_hp_rate = param.skill_power_hp_rate;
activity.m_skill_absorb = param.skill_absorb;
activity.m_skill_kickback = param.skill_kickback;
activity.m_skill_kickback_fix = param.skill_kickback_fix;
activity.m_skill_chk_atk_affinity = param.skill_chk_atk_affinity;
activity.m_skill_chk_atk_leader = param.skill_chk_atk_leader;
activity.m_skill_chk_atk_passive = param.skill_chk_atk_passive;
activity.m_skill_chk_atk_ailment = param.skill_chk_atk_ailment;
activity.m_skill_chk_atk_combo = MasterDataDefineLabel.BoolType.DISABLE; // コンボレートはのらない
activity.m_skill_chk_def_defence = param.skill_chk_def_defence;
activity.m_skill_chk_def_ailment = param.skill_chk_def_ailment;
activity.m_skill_chk_def_barrier = param.skill_chk_def_barrier;
activity.m_statusAilment_target = param.status_ailment_target;
activity.m_statusAilment = new int[] { param.status_ailment1,
param.status_ailment2,
param.status_ailment3,
param.status_ailment4 };
activity._setParam(param);
return(activity);
}
public void setup(MasterDataParamChara _master, PacketStructUnit _mainUnit, PacketStructUnit _subUnit = null, bool bFakeLink = false, bool bPink = false)
{
CharaOnce baseChara = new CharaOnce();
CharaOnce prevChara = null;
MasterDataLimitOver _masterMainLO = MasterFinder <MasterDataLimitOver> .Instance.Find((int)_master.limit_over_type);
if (_masterMainLO == null)
{
return;
}
MasterDataSkillLimitBreak _masterMainLB = MasterFinder <MasterDataSkillLimitBreak> .Instance.Find((int)_master.skill_limitbreak);
CharaName = _master.name;
string noFormat = GameTextUtil.GetText("unit_status1");
CharaNo = string.Format(noFormat, _master.draw_id);
Rarity = (uint)_master.rare + 1;
RaceImage = MainMenuUtil.GetTextKindSprite(_master.kind, false);
if (_master.sub_kind != MasterDataDefineLabel.KindType.NONE)
{
SubRaceImage = MainMenuUtil.GetTextKindSprite(_master.sub_kind, false);
}
else
{
SubRaceImage = null;
}
AttributeImage = MainMenuUtil.GetTextElementSprite(_master.element);
AttributeImageColor = ColorUtil.GetElementLabelColor(_master.element);
if (bPink == true)
{
prevChara = new CharaOnce();
prevChara.CharaSetupFromID(
_mainUnit.id,
(int)_mainUnit.level,
(int)_mainUnit.limitbreak_lv,
(int)_mainUnit.limitover_lv,
(int)_mainUnit.add_pow,
(int)_mainUnit.add_hp,
0,
0,
0,
0,
0,
0
);
}
if (_mainUnit.link_info == (uint)ServerDataDefine.CHARALINK_TYPE.CHARALINK_TYPE_BASE &&
_subUnit != null)
{
baseChara.CharaSetupFromID(
_mainUnit.id,
(int)_mainUnit.level,
(int)_mainUnit.limitbreak_lv,
(int)_mainUnit.limitover_lv,
(int)_mainUnit.add_pow,
(int)_mainUnit.add_hp,
_subUnit.id,
(int)_subUnit.level,
(int)_subUnit.add_pow,
(int)_subUnit.add_hp,
(int)_mainUnit.link_point,
(int)_subUnit.limitover_lv
);
}
else if (bFakeLink && _subUnit != null)
{
baseChara.CharaSetupFromID(
_mainUnit.id,
(int)_mainUnit.level,
(int)_mainUnit.limitbreak_lv,
(int)_mainUnit.limitover_lv,
(int)_mainUnit.add_pow,
(int)_mainUnit.add_hp,
_subUnit.id,
(int)_subUnit.level,
(int)_subUnit.add_pow,
(int)_subUnit.add_hp,
(int)0,
(int)_subUnit.limitover_lv
);
}
else
{
baseChara.CharaSetupFromID(
_mainUnit.id,
(int)_mainUnit.level,
(int)_mainUnit.limitbreak_lv,
(int)_mainUnit.limitover_lv,
(int)_mainUnit.add_pow,
(int)_mainUnit.add_hp,
0,
0,
0,
0,
0,
0
);
}
if (IsViewExp == true)
{
//-----------------------
// 次のレベルまでの経験値を算出
//-----------------------
int nNowLevelExp = CharaUtil.GetStatusValue(_master, (int)_mainUnit.level, CharaUtil.VALUE.EXP);
int nNextLevelExp = CharaUtil.GetStatusValue(_master, (int)_mainUnit.level + 1, CharaUtil.VALUE.EXP);
int nLevelupExp = nNextLevelExp - nNowLevelExp;
int nNextEXP = nNextLevelExp - (int)_mainUnit.exp;
float expRatio = 0.0f;
if (nNextEXP != 0)
{
expRatio = (float)(nLevelupExp - nNextEXP) / nLevelupExp;
}
NextExp = nNextEXP;
ExpRate = expRatio;
}
setParam(baseChara, _master, _masterMainLO, _masterMainLB, _subUnit, prevChara);
}
// Update is called once per frame
void Update()
{
if (BattleParam.m_PlayerParty != null && BattleParam.isActiveBattle())
{
BattleSceneUtil.MultiInt damage_value = BattleParam.m_PlayerParty.getDispDamageValue();
BattleSceneUtil.MultiInt heal_value = BattleParam.m_PlayerParty.getDispRecoveryValue();
if (BattleParam.m_PlayerParty.m_HPCurrent.getValue(GlobalDefine.PartyCharaIndex.MAX) != m_PartyHp ||
BattleParam.m_PlayerParty.m_HPMax.getValue(GlobalDefine.PartyCharaIndex.MAX) != m_PartyHpMax
)
{
m_PartyHp = BattleParam.m_PlayerParty.m_HPCurrent.getValue(GlobalDefine.PartyCharaIndex.MAX);
m_PartyHpMax = BattleParam.m_PlayerParty.m_HPMax.getValue(GlobalDefine.PartyCharaIndex.MAX);
if (m_PartyHpObject != null)
{
TextMesh text_mesh = m_PartyHpObject.GetComponent <TextMesh>();
if (text_mesh != null)
{
text_mesh.text = "HP:" + m_PartyHp.ToString() + "/" + m_PartyHpMax.ToString();
}
}
}
if (damage_value != null)
{
int hp_delta = damage_value.getValue(GlobalDefine.PartyCharaIndex.MAX);
if (hp_delta > 0)
{
DrawDamageManager.showDamage(m_PartyHpDamageLocale.transform, hp_delta, EDAMAGE_TYPE.eDAMAGE_TYPE_WEEK);
}
}
if (heal_value != null)
{
int hp_delta = heal_value.getValue(GlobalDefine.PartyCharaIndex.MAX);
if (hp_delta > 0)
{
DrawDamageManager.showDamage(m_PartyHpDamageLocale.transform, hp_delta, EDAMAGE_TYPE.eDAMAGE_TYPE_HEAL);
EffectManager.Instance.playEffect(SceneObjReferGameMain.Instance.m_EffectPrefab.m_Heal_03, new Vector3(2.0f * 0.05f, -0.9609375f * 0.05f, 0.0f), Vector3.zero, m_PartyHpObject.transform, null, 0.15f);
}
}
if (BattleParam.m_PlayerParty.m_PartyTotalSP != m_PartySp ||
BattleParam.m_PlayerParty.m_PartyTotalSPMax != m_PartySpMax
)
{
int old_sp = m_PartySp;
m_PartySp = BattleParam.m_PlayerParty.m_PartyTotalSP;
m_PartySpMax = BattleParam.m_PlayerParty.m_PartyTotalSPMax;
if (m_PartySpObject != null)
{
TextMesh text_mesh = m_PartySpObject.GetComponent <TextMesh>();
if (text_mesh != null)
{
text_mesh.text = "SP:" + m_PartySp.ToString() + "/" + m_PartySpMax.ToString();
}
if (m_PartySp > old_sp)
{
EffectManager.Instance.playEffect(SceneObjReferGameMain.Instance.m_EffectPrefab.m_Heal_SP, new Vector3(2.0f * 0.05f, -0.4f * 0.05f, 0.0f), Vector3.zero, m_PartySpObject.transform, null, 0.125f);
}
}
}
// パーティ状態異常
{
Transform ailment_object = transform.Find("PartyAilment");
if (ailment_object != null)
{
InGameAilmentIcon ailment_icon = ailment_object.GetComponent <InGameAilmentIcon>();
if (ailment_icon != null)
{
StatusAilmentChara ailment_info = BattleParam.m_PlayerParty.m_Ailments.getAilment(GlobalDefine.PartyCharaIndex.MAX);
ailment_icon.SetStatus(ailment_info);
}
}
}
bool is_control = false;
if (BattleParam.getBattlePhase() == BattleParam.BattlePhase.INPUT)
{
is_control = true;
}
// ヒーロースキル発動ボタン
{
Transform hero_skill_button_trans = transform.Find("Canvas/ButtonHeroSkill");
if (hero_skill_button_trans != null)
{
Button button = hero_skill_button_trans.GetComponent <Button>();
if (button != null)
{
bool is_button_enable = (is_control && BattleParam.m_PlayerParty.m_BattleHero.checkHeroSkillTurn());
button.interactable = is_button_enable;
Transform btn_txt = hero_skill_button_trans.Find("Text");
if (btn_txt != null)
{
Text txt = btn_txt.GetComponent <Text>();
if (txt != null)
{
txt.text = BattleParam.m_PlayerParty.m_BattleHero.getSkillTurn().ToString() + "/HERO";
}
}
}
}
}
GlobalDefine.PartyCharaIndex provoke_target = BattleParam.m_PlayerParty._getProvokeTarget();
for (int idx = 0; idx < (int)GlobalDefine.PartyCharaIndex.MAX; idx++)
{
string chara_name = "";
int chara_id = 0;
int link_chara_id = 0;
string hp_text = "";
string skill_name = "";
bool is_active_skill_button = false;
CharaOnce chara_once = BattleParam.m_PlayerParty.getPartyMember((GlobalDefine.PartyCharaIndex)idx, CharaParty.CharaCondition.EXIST);
bool is_alive = false;
if (chara_once != null)
{
MasterDataParamChara chara_master = chara_once.m_CharaMasterDataParam;
int hp = BattleParam.m_PlayerParty.m_HPCurrent.getValue((GlobalDefine.PartyCharaIndex)idx);
float hp_rate = hp / (float)BattleParam.m_PlayerParty.m_HPMax.getValue((GlobalDefine.PartyCharaIndex)idx);
string hp_color = "white";
if (hp_rate >= 0.5f)
{
hp_color = "white";
is_alive = true;
}
else
if (hp_rate >= 0.2f)
{
hp_color = "yellow";
is_alive = true;
}
else
if (hp_rate > 0.0f)
{
hp_color = "red";
is_alive = true;
}
else
{
hp_color = "#808080";
}
// キャラ名
chara_name = "<color=" + hp_color + ">" + chara_master.name + "</color>";
// キャライメージ
chara_id = (int)chara_master.fix_id;
// リンクキャライメージ
if (chara_once.m_LinkParam != null)
{
link_chara_id = (int)chara_once.m_LinkParam.m_CharaID;
}
int atk_percent = (int)(InGameUtil.getCharaAttakPowScale(chara_once, BattleParam.m_PlayerParty.m_Ailments.getAilment((GlobalDefine.PartyCharaIndex)idx)) * 100.0f);
int hp_percent = (int)(BattleParam.m_PlayerParty.m_HPMax.getValue((GlobalDefine.PartyCharaIndex)idx) / (float)BattleParam.m_PlayerParty.m_HPBase.getValue((GlobalDefine.PartyCharaIndex)idx) * 100.0f);
// キャラ個別ＨＰ
hp_text = "<color=" + hp_color + ">"
+ BattleParam.m_PlayerParty.m_HPCurrent.getValue((GlobalDefine.PartyCharaIndex)idx)
+ "/" + BattleParam.m_PlayerParty.m_HPMax.getValue((GlobalDefine.PartyCharaIndex)idx)
+ "</color>";
if (BattleParam.IsKobetsuHP)
{
hp_text += " <color=#a0a0a0>HP" + hp_percent.ToString() + "%\n";
if (BattleParam.m_PlayerParty.m_Hate_ProvokeTurn.getValue((GlobalDefine.PartyCharaIndex)idx) > 0)
{
if (provoke_target == (GlobalDefine.PartyCharaIndex)idx)
{
hp_text += "[挑発]:";
}
else
{
hp_text += "挑発:";
}
hp_text += BattleParam.m_PlayerParty.m_Hate_ProvokeTurn.getValue((GlobalDefine.PartyCharaIndex)idx);
}
else
{
hp_text += "Hate:" + BattleParam.m_PlayerParty.m_Hate.getValue((GlobalDefine.PartyCharaIndex)idx);
}
hp_text += " ATK" + atk_percent.ToString() + "%</color>";
}
// スキルターン
int skill_turn = chara_once.GetTrunToLimitBreak();
MasterDataSkillLimitBreak skill_limit_break = BattleParam.m_MasterDataCache.useSkillLimitBreak(chara_master.skill_limitbreak);
if (skill_limit_break != null)
{
skill_name = skill_turn.ToString() + "/" + skill_limit_break.name;
}
// ボタンのアクティブ・非アクティブ
{
is_active_skill_button = is_control && BattleParam.IsEnableLBS((GlobalDefine.PartyCharaIndex)idx);
}
}
// 表示
{
// キャラ名
{
Transform chara_name_trans = m_MemberObject[idx].transform.Find("CharaName");
if (chara_name_trans != null)
{
Text text_component = chara_name_trans.GetComponent <Text>();
if (text_component != null)
{
text_component.text = chara_name;
}
}
}
}
// スキル発動条件表示
{
{
MasterDataDefineLabel.ElementType[,] skill_costs = new MasterDataDefineLabel.ElementType[2, 5];
if (is_alive)
{
MasterDataParamChara chara_master = chara_once.m_CharaMasterDataParam;
if (chara_master.skill_active0 != 0)
{
MasterDataSkillActive skill_active0 = BattleParam.m_MasterDataCache.useSkillActive(chara_master.skill_active0);
if (skill_active0 != null)
{
skill_costs[0, 0] = skill_active0.cost1;
skill_costs[0, 1] = skill_active0.cost2;
skill_costs[0, 2] = skill_active0.cost3;
skill_costs[0, 3] = skill_active0.cost4;
skill_costs[0, 4] = skill_active0.cost5;
}
}
if (chara_master.skill_active1 != 0)
{
MasterDataSkillActive skill_active1 = BattleParam.m_MasterDataCache.useSkillActive(chara_master.skill_active1);
if (skill_active1 != null)
{
skill_costs[1, 0] = skill_active1.cost1;
skill_costs[1, 1] = skill_active1.cost2;
skill_costs[1, 2] = skill_active1.cost3;
skill_costs[1, 3] = skill_active1.cost4;
skill_costs[1, 4] = skill_active1.cost5;
}
}
}
for (int skill_idx = 0; skill_idx < 2; skill_idx++)
{
for (int cost_idx = 0; cost_idx < 5; cost_idx++)
{
Transform cost_trans = m_MemberObject[idx].transform.Find("SkillInfo/Skill" + skill_idx.ToString() + cost_idx.ToString());
if (cost_trans != null)
{
MasterDataDefineLabel.ElementType element_type = skill_costs[skill_idx, cost_idx];
if (element_type != MasterDataDefineLabel.ElementType.NONE)
{
Image img = cost_trans.GetComponent <Image>();
if (img != null)
{
img.sprite = m_SkillCostElements[(int)element_type];
cost_trans.gameObject.SetActive(true);
}
else
{
cost_trans.gameObject.SetActive(false);
}
}
else
{
cost_trans.gameObject.SetActive(false);
}
}
}
}
}
// キャライメージ
{
Transform chara_image_trans = m_MemberObject[idx].transform.Find("Image");
if (chara_image_trans != null)
{
BattleCharaImageViewControl chara_view_control = chara_image_trans.GetComponent <BattleCharaImageViewControl>();
if (chara_view_control != null)
{
chara_view_control.setCharaID(chara_id, BattleCharaImageViewControl.ImageType.FACE);
}
}
}
// リンクキャライメージ
{
Transform chara_image_trans = m_MemberObject[idx].transform.Find("ImageLink");
if (chara_image_trans != null)
{
BattleCharaImageViewControl chara_view_control = chara_image_trans.GetComponent <BattleCharaImageViewControl>();
if (chara_view_control != null)
{
chara_view_control.setCharaID(link_chara_id, BattleCharaImageViewControl.ImageType.FACE);
}
}
}
// キャラ個別ＨＰ
{
Transform chara_hp_trans = m_MemberObject[idx].transform.Find("HP");
if (chara_hp_trans != null)
{
Text text_component = chara_hp_trans.GetComponent <Text>();
if (text_component != null)
{
text_component.text = hp_text;
}
}
if (damage_value != null)
{
int hp_delta = damage_value.getValue((GlobalDefine.PartyCharaIndex)idx);
if (hp_delta > 0)
{
DrawDamageManager.showDamage(chara_hp_trans, hp_delta, EDAMAGE_TYPE.eDAMAGE_TYPE_WEEK, 50.0f);
}
}
if (heal_value != null)
{
int hp_delta = heal_value.getValue((GlobalDefine.PartyCharaIndex)idx);
if (hp_delta > 0)
{
DrawDamageManager.showDamage(chara_hp_trans, hp_delta, EDAMAGE_TYPE.eDAMAGE_TYPE_HEAL, 50.0f);
EffectManager.Instance.playEffect(SceneObjReferGameMain.Instance.m_EffectPrefab.m_Heal_03, new Vector3(0.01975f, -0.0246875f, 0.0f), Vector3.zero, chara_hp_trans, null, 50.0f * 3.0f);
}
}
}
// スキルターン
Transform skill_turn_trans = m_MemberObject[idx].transform.Find("SkillButton");
if (skill_turn_trans != null)
{
Text text_component = skill_turn_trans.GetChild(0).GetComponent <Text>();
if (text_component != null)
{
text_component.text = skill_name;
}
// ボタンのアクティブ・非アクティブ
{
Button button = skill_turn_trans.GetComponent <Button>();
button.interactable = is_active_skill_button;
}
}
}
// 敵にターゲットされているかどうかの表示
{
Transform lock_on_object = m_MemberObject[idx].transform.Find("ImageLockOn");
if (lock_on_object != null)
{
lock_on_object.gameObject.SetActive(BattleParam.m_EnemyToPlayerTarget == (GlobalDefine.PartyCharaIndex)idx);
}
}
// 状態異常
if (chara_once != null)
{
Transform ailment_object = m_MemberObject[idx].transform.Find("Ailment");
if (ailment_object != null)
{
InGameAilmentIcon ailment_icon = ailment_object.GetComponent <InGameAilmentIcon>();
if (ailment_icon != null)
{
StatusAilmentChara ailment_info = BattleParam.m_PlayerParty.m_Ailments.getAilment((GlobalDefine.PartyCharaIndex)idx);
ailment_icon.SetStatus(ailment_info); //毎フレーム設定する必要はないがとりあえず設定しておく
}
}
}
}
}
}
public void setupChara(uint unit_id, StatusType _type, uint limitover_lv = 0, uint plus_pow = 0, uint plus_hp = 0)
{
MasterDataParamChara _masterMain = MasterFinder <MasterDataParamChara> .Instance.Find((int)unit_id);
if (_masterMain == null)
{
return;
}
MasterDataLimitOver _masterMainLO = MasterFinder <MasterDataLimitOver> .Instance.Find((int)_masterMain.limit_over_type);
if (_masterMainLO == null)
{
return;
}
CharaOnce baseChara = new CharaOnce();
if (_type == StatusType.LV_1)
{
baseChara.CharaSetupFromID(
unit_id,
(int)1,
(int)0,
(int)limitover_lv,
(int)plus_pow,
(int)plus_hp,
0,
0,
0,
0,
0,
0
);
}
else
{
int _limitBreakLevel = 0;
if (_masterMain.skill_limitbreak != 0)
{
MasterDataSkillLimitBreak _masterLimitBreak = MasterFinder <MasterDataSkillLimitBreak> .Instance.Find((int)_masterMain.skill_limitbreak);
_limitBreakLevel = _masterLimitBreak.level_max;
}
baseChara.CharaSetupFromID(
unit_id,
(int)_masterMain.level_max,
(int)_limitBreakLevel,
(int)_masterMainLO.limit_over_max,
(int)GlobalDefine.PLUS_MAX,
(int)GlobalDefine.PLUS_MAX,
0,
0,
0,
0,
0,
0
);
}
setParam(baseChara, _masterMain, _masterMainLO);
}
//----------------------------------------------------------------------------
/*!
@brief キャラ情報セットアップ：マスターデータ指定
@param MasterDataParamChara cMasterData キャラマスター
@param int nLevel キャラレベル
@param int lbsLv リミットブレイクスキルレベル
@param int nPlusPow プラス値：攻撃
@param int nPlusHP プラス値：体力
@param int nLOLevel プラス値：限界突破値
@note
*/
//----------------------------------------------------------------------------
public bool CharaSetupFromParam(MasterDataParamChara cMasterData, int nLevel, int lbsLv, int nPlusPow, int nPlusHP, int nLOLevel)
{
m_CharaMasterDataParam = cMasterData;
m_bHasCharaMasterDataParam = (null != m_CharaMasterDataParam);
if (m_CharaMasterDataParam == null)
{
Debug.LogError("CharaSetup Error! - InstanceNone!! ");
return false;
}
// @change Developer 2015/09/03 ver300
#region ==== 通常処理 ====
int nPlusValuePow = 0;
int nPlusValueHP = 0;
m_CharaLevel = nLevel;
m_CharaLBSLv = lbsLv;
float fLimitOverHP = 0;
float fLimitOverATK = 0;
#region ==== スキルレベルまるめ処理 ====
MasterDataSkillLimitBreak cSkillLimitBreak = BattleParam.m_MasterDataCache.useSkillLimitBreak(cMasterData.skill_limitbreak);
if (cSkillLimitBreak != null)
{
if (lbsLv > cSkillLimitBreak.level_max)
{
m_CharaLBSLv = cSkillLimitBreak.level_max;
}
}
#endregion
#region ==== リミットオーバーまるめ処理 ====
MasterDataLimitOver _masterMainLO = MasterFinder<MasterDataLimitOver>.Instance.Find((int)cMasterData.limit_over_type);
if (_masterMainLO != null)
{
if (nLOLevel > _masterMainLO.limit_over_max)
{
nLOLevel = _masterMainLO.limit_over_max;
}
}
#endregion
m_CharaPow = CharaUtil.GetStatusValue(m_CharaMasterDataParam, nLevel, CharaUtil.VALUE.POW);
m_CharaDef = CharaUtil.GetStatusValue(m_CharaMasterDataParam, nLevel, CharaUtil.VALUE.DEF);
m_CharaHP = CharaUtil.GetStatusValue(m_CharaMasterDataParam, nLevel, CharaUtil.VALUE.HP);
m_CharaLimitBreak = 0;
m_CharaPlusPow = nPlusPow;
m_CharaPlusDef = 0;
m_CharaPlusHP = nPlusHP;
m_CharaLimitOver = nLOLevel;
m_CharaCharm = CharaLimitOver.GetParamCharm((uint)nLOLevel, cMasterData.limit_over_type);
// レベルMAXなら限界突破の値を追加
float fLimitOverAddHp = CharaLimitOver.GetParam((uint)nLOLevel, cMasterData.limit_over_type, (int)CharaLimitOver.EGET.ePARAM_HP);
float fLimitOverAddAtk = CharaLimitOver.GetParam((uint)nLOLevel, cMasterData.limit_over_type, (int)CharaLimitOver.EGET.ePARAM_ATK);
fLimitOverHP = m_CharaHP * (fLimitOverAddHp / 100);
fLimitOverATK = m_CharaPow * (fLimitOverAddAtk / 100);
// プラス値を算出
nPlusValuePow = m_CharaPlusPow * GlobalDefine.PLUS_RATE_POW;
nPlusValueHP = m_CharaPlusHP * GlobalDefine.PLUS_RATE_HP;
#endregion
// @add Developer 2015/09/03 ver300
#region ==== リンクシステム処理 ====
int nElemValuePow = 0;
int nElemValueHP = 0;
int nRaceValuePow = 0;
int nRaceValueHP = 0;
int nLinkPlusValuePow = 0;
int nLinkPlusValueHP = 0;
double nLinkCharm = 0;
// リンク中の場合
//MasterDataParamChara cLinkCharaMaster = BattleParam.m_MasterDataCache.useCharaParam(m_LinkParam.m_CharaID);
MasterDataParamChara cLinkCharaMaster = m_LinkParam.m_cCharaMasterDataParam;
if (cLinkCharaMaster != null)
{
float fWork = 0.0f;
// 属性ボーナスを加算
nElemValuePow = CharaLinkUtil.GetLinkUnitBonusElement(cLinkCharaMaster, m_LinkParam.m_CharaLv, (uint)m_LinkParam.m_CharaLOLevel, CharaUtil.VALUE.POW);
nElemValueHP = CharaLinkUtil.GetLinkUnitBonusElement(cLinkCharaMaster, m_LinkParam.m_CharaLv, (uint)m_LinkParam.m_CharaLOLevel, CharaUtil.VALUE.HP);
// 種族ボーナス：攻撃力の+%値を算出
fWork = CharaLinkUtil.GetLinkUnitBonusRace(cLinkCharaMaster, cLinkCharaMaster.kind, CharaUtil.VALUE.POW); // %値取得(メイン)
fWork += CharaLinkUtil.GetLinkUnitBonusRace(cLinkCharaMaster, cLinkCharaMaster.sub_kind, CharaUtil.VALUE.POW); // %値取得(サブ)
fWork = InGameUtilBattle.GetDBRevisionValue(fWork); // 数値変換
nRaceValuePow = (int)InGameUtilBattle.AvoidErrorMultiple((float)m_CharaPow, fWork); // 増加量
// 種族ボーナス：体力の実値を取得
nRaceValueHP = (int)CharaLinkUtil.GetLinkUnitBonusRace(cLinkCharaMaster, cLinkCharaMaster.kind, CharaUtil.VALUE.HP); // 実値取得(メイン)
nRaceValueHP += (int)CharaLinkUtil.GetLinkUnitBonusRace(cLinkCharaMaster, cLinkCharaMaster.sub_kind, CharaUtil.VALUE.HP); // 実値取得(サブ)
// +値の算出
nLinkPlusValuePow = CharaLinkUtil.GetLinkUnitBonusPlus(m_LinkParam.m_CharaPlusPow, CharaUtil.VALUE.POW);
nLinkPlusValueHP = CharaLinkUtil.GetLinkUnitBonusPlus(m_LinkParam.m_CharaPlusHP, CharaUtil.VALUE.HP);
nLinkCharm = CharaLimitOver.GetParamCharm((uint)m_LinkParam.m_CharaLOLevel, cLinkCharaMaster.limit_over_type);
}
else
{
// リンク用変数の初期化
m_LinkParam.Setup();
}
#endregion
#if BUILD_TYPE_DEBUG
DebugBattleLog.writeText(DebugBattleLog.StrOpe + "キャラ基本情報"
+ "[" + cMasterData.name + "]"
+ " FixID:" + cMasterData.fix_id
+ " DrawID:" + cMasterData.draw_id
+ " LV:" + m_CharaLevel.ToString()
+ " SkillLV:" + m_CharaLBSLv.ToString()
+ " LimOverLv:" + m_CharaLimitOver.ToString()
+ " PlusPow:" + m_CharaPlusPow.ToString()
+ " PlusHp:" + m_CharaPlusHP.ToString()
+ " 属性:" + cMasterData.element.ToString()
+ " 種族1:" + cMasterData.kind.ToString()
+ " 種族2:" + cMasterData.sub_kind.ToString()
);
DebugBattleLog.writeText(DebugBattleLog.StrOpe + " HP(" + (m_CharaHP + nPlusValueHP + nElemValueHP + nRaceValueHP + nLinkPlusValueHP + (int)fLimitOverHP).ToString() + ")"
+ " = LV(" + m_CharaHP.ToString() + ")"
+ " + PlusHP(" + nPlusValueHP.ToString() + ")"
+ " + LinkElem(" + nElemValueHP.ToString() + ")"
+ " + LinkRace(" + nRaceValueHP.ToString() + ")"
+ " + LinkPlus(" + nLinkPlusValueHP.ToString() + ")"
+ " + LimitOver(" + ((int)fLimitOverHP).ToString() + ")"
);
DebugBattleLog.writeText(DebugBattleLog.StrOpe + " POW(" + (m_CharaPow + nPlusValuePow + nElemValuePow + nRaceValuePow + nLinkPlusValuePow + (int)fLimitOverATK).ToString() + ")"
+ " = LV(" + m_CharaPow.ToString() + ")"
+ " + PlusPow(" + nPlusValuePow.ToString() + ")"
+ " + LinkElem(" + nElemValuePow.ToString() + ")"
+ " + LinkRace(" + nRaceValuePow.ToString() + ")"
+ " + LinkPlus(" + nLinkPlusValuePow.ToString() + ")"
+ " + LimitOver(" + ((int)fLimitOverATK).ToString() + ")"
);
const int ADD_SKILL_COUNT_LIMIT = 50; // スキル連結数の上限
if (cMasterData.skill_leader != 0)
{
DebugBattleLog.writeText(DebugBattleLog.StrOpe + " リーダースキル(fixid:" + cMasterData.skill_leader.ToString(), false);
MasterDataSkillLeader master_data = BattleParam.m_MasterDataCache.useSkillLeader(cMasterData.skill_leader);
if (master_data == null)
{
DebugBattleLog.writeText(DebugBattleLog.StrOpe + "ERROR!（存在しないfix_id）)");
}
else
{
DebugBattleLog.writeText(DebugBattleLog.StrOpe + ")[" + master_data.name + "]" + master_data.detail);
}
}
if (cMasterData.skill_limitbreak != 0)
{
DebugBattleLog.writeText(DebugBattleLog.StrOpe + " リミブレスキル(fixid:" + cMasterData.skill_limitbreak.ToString(), false);
MasterDataSkillLimitBreak master_data = BattleParam.m_MasterDataCache.useSkillLimitBreak(cMasterData.skill_limitbreak);
if (master_data == null)
{
DebugBattleLog.writeText(DebugBattleLog.StrOpe + "ERROR!（存在しないfix_id）)");
}
else
{
int loop_limit = ADD_SKILL_COUNT_LIMIT;
int add_fix_id = master_data.add_fix_id;
while (add_fix_id != 0)
{
DebugBattleLog.writeText(DebugBattleLog.StrOpe + "+" + add_fix_id.ToString(), false);
MasterDataSkillLimitBreak add_master_data = BattleParam.m_MasterDataCache.useSkillLimitBreak((uint)add_fix_id);
if (add_master_data == null)
{
DebugBattleLog.writeText(DebugBattleLog.StrOpe + "ERROR!（存在しないfix_id）)");
break;
}
add_fix_id = add_master_data.add_fix_id;
loop_limit--;
if (loop_limit <= 0)
{
DebugBattleLog.writeText(DebugBattleLog.StrOpe + "ERROR!（無限ループ）)");
}
}
DebugBattleLog.writeText(DebugBattleLog.StrOpe + ")[" + master_data.name + "]" + master_data.detail);
}
}
if (cMasterData.skill_active0 != 0)
{
DebugBattleLog.writeText(DebugBattleLog.StrOpe + " ノーマルスキル1(fixid:" + cMasterData.skill_active0.ToString(), false);
MasterDataSkillActive master_data = BattleParam.m_MasterDataCache.useSkillActive(cMasterData.skill_active0);
if (master_data == null)
{
DebugBattleLog.writeText(DebugBattleLog.StrOpe + "ERROR!（存在しないfix_id）)");
}
else
{
DebugBattleLog.writeText(DebugBattleLog.StrOpe + ")[" + master_data.name + "]" + master_data.detail);
}
}
if (cMasterData.skill_active1 != 0)
{
DebugBattleLog.writeText(DebugBattleLog.StrOpe + " ノーマルスキル2(fixid:" + cMasterData.skill_active1.ToString(), false);
MasterDataSkillActive master_data = BattleParam.m_MasterDataCache.useSkillActive(cMasterData.skill_active1);
if (master_data == null)
{
DebugBattleLog.writeText(DebugBattleLog.StrOpe + "ERROR!（存在しないfix_id）)");
}
else
{
DebugBattleLog.writeText(DebugBattleLog.StrOpe + ")[" + master_data.name + "]" + master_data.detail);
}
}
if (cMasterData.skill_passive != 0)
{
DebugBattleLog.writeText(DebugBattleLog.StrOpe + " パッシブスキル(fixid:" + cMasterData.skill_passive.ToString(), false);
MasterDataSkillPassive master_data = BattleParam.m_MasterDataCache.useSkillPassive(cMasterData.skill_passive);
if (master_data == null)
{
DebugBattleLog.writeText(DebugBattleLog.StrOpe + "ERROR!（存在しないfix_id）)");
}
else
{
int loop_limit = ADD_SKILL_COUNT_LIMIT;
int add_fix_id = master_data.add_fix_id;
while (add_fix_id != 0)
{
DebugBattleLog.writeText(DebugBattleLog.StrOpe + "+" + add_fix_id.ToString(), false);
MasterDataSkillPassive add_master_data = BattleParam.m_MasterDataCache.useSkillPassive((uint)add_fix_id);
if (add_master_data == null)
{
DebugBattleLog.writeText(DebugBattleLog.StrOpe + "ERROR!（存在しないfix_id）)");
break;
}
add_fix_id = add_master_data.add_fix_id;
loop_limit--;
if (loop_limit <= 0)
{
DebugBattleLog.writeText(DebugBattleLog.StrOpe + "ERROR!（無限ループ）)");
}
}
DebugBattleLog.writeText(DebugBattleLog.StrOpe + ")[" + master_data.name + "]" + master_data.detail);
}
}
if (cLinkCharaMaster != null)
{
DebugBattleLog.writeText(DebugBattleLog.StrOpe + " リンクキャラ"
+ "[" + cLinkCharaMaster.name + "]"
+ " FixID:" + cLinkCharaMaster.fix_id
+ " DrawID:" + cLinkCharaMaster.draw_id
+ " LV:" + m_LinkParam.m_CharaLv.ToString()
+ " LimOverLv:" + m_LinkParam.m_CharaLOLevel.ToString()
+ " PlusPow:" + m_LinkParam.m_CharaPlusPow.ToString()
+ " PlusHp:" + m_LinkParam.m_CharaPlusHP.ToString()
+ " LinkPoint:" + m_LinkParam.m_CharaLinkPoint.ToString()
);
if (cLinkCharaMaster.link_skill_active != 0)
{
DebugBattleLog.writeText(DebugBattleLog.StrOpe + " リンクスキル(fixid:" + cLinkCharaMaster.link_skill_active.ToString(), false);
MasterDataSkillActive master_data = BattleParam.m_MasterDataCache.useSkillActive(cLinkCharaMaster.link_skill_active);
if (master_data == null)
{
DebugBattleLog.writeText(DebugBattleLog.StrOpe + "ERROR!（存在しないfix_id）)");
}
else
{
DebugBattleLog.writeText(DebugBattleLog.StrOpe + ")[" + master_data.name + "]" + master_data.detail);
}
}
if (cLinkCharaMaster.link_skill_passive != 0)
{
DebugBattleLog.writeText(DebugBattleLog.StrOpe + " リンクパッシブスキル(fixid:" + cLinkCharaMaster.link_skill_passive.ToString(), false);
MasterDataSkillPassive master_data = BattleParam.m_MasterDataCache.useSkillPassive(cLinkCharaMaster.link_skill_passive);
if (master_data == null)
{
DebugBattleLog.writeText(DebugBattleLog.StrOpe + "ERROR!（存在しないfix_id）)");
}
else
{
int loop_limit = ADD_SKILL_COUNT_LIMIT;
int add_fix_id = master_data.add_fix_id;
while (add_fix_id != 0)
{
DebugBattleLog.writeText(DebugBattleLog.StrOpe + "+" + add_fix_id.ToString(), false);
MasterDataSkillPassive add_master_data = BattleParam.m_MasterDataCache.useSkillPassive((uint)add_fix_id);
if (add_master_data == null)
{
DebugBattleLog.writeText(DebugBattleLog.StrOpe + "ERROR!（存在しないfix_id）)");
break;
}
add_fix_id = add_master_data.add_fix_id;
loop_limit--;
if (loop_limit <= 0)
{
DebugBattleLog.writeText(DebugBattleLog.StrOpe + "ERROR!（無限ループ）)");
}
}
DebugBattleLog.writeText(DebugBattleLog.StrOpe + ")[" + master_data.name + "]" + master_data.detail);
}
}
}
#endif //BUILD_TYPE_DEBUG
// 攻撃力、体力の増加値を加算
m_CharaPow += nPlusValuePow + nElemValuePow + nRaceValuePow + nLinkPlusValuePow + (int)fLimitOverATK;
m_CharaHP += nPlusValueHP + nElemValueHP + nRaceValueHP + nLinkPlusValueHP + (int)fLimitOverHP;
m_CharaCharm += nLinkCharm;
if (m_CharaPow > GlobalDefine.VALUE_MAX_POW)
{
m_CharaPow = GlobalDefine.VALUE_MAX_POW;
}
if (m_CharaHP > GlobalDefine.VALUE_MAX_HP)
{
m_CharaHP = GlobalDefine.VALUE_MAX_HP;
}
return true;
}
IEnumerator WaitScrollContent()
{
while (m_baseChara == null)
{
yield return(null);
}
yield return(null);
IsViewScroll = true;
while (LeaderSkillRect.sizeDelta.y == 0)
{
yield return(null);
}
ScrollBarViewHeight = ScrollViewRect.sizeDelta.y;
float LeaderSkillHeight = LeaderSkillRect.sizeDelta.y;
float LinkUnitInfoHeight = LinkUnitInfoRect.sizeDelta.y;
while (LinkScrollRect.content.sizeDelta.y < (LeaderSkillHeight + LinkUnitInfoHeight))
{
IsViewScroll = false;
yield return(null);
IsViewScroll = true;
yield return(null);
}
if ((LeaderSkillHeight + LinkUnitInfoHeight) > ScrollBarViewHeight)
{
while (LinkScrollRect.verticalScrollbar.IsActive() == false)
{
yield return(null);
}
}
/**
* メインユニット情報
*/
if (m_baseChara.m_CharaMasterDataParam != null)
{
baseUnitInfo.Name = m_baseChara.m_CharaMasterDataParam.name;
baseUnitInfo.Rarity = (int)m_baseChara.m_CharaMasterDataParam.rare + 1;
baseUnitInfo.MainRace = MainMenuUtil.GetTextKindSprite(m_baseChara.m_CharaMasterDataParam.kind, false);
baseUnitInfo.IsViewSubRace = false;
if (m_baseChara.m_CharaMasterDataParam.sub_kind != MasterDataDefineLabel.KindType.NONE)
{
baseUnitInfo.SubRace = MainMenuUtil.GetTextKindSprite(m_baseChara.m_CharaMasterDataParam.sub_kind, false);
baseUnitInfo.IsViewSubRace = true;
}
baseUnitInfo.Element = MainMenuUtil.GetTextElementSprite(m_baseChara.m_CharaMasterDataParam.element);
baseUnitInfo.ElementColor = ColorUtil.GetElementLabelColor(m_baseChara.m_CharaMasterDataParam.element);
string levelFormat = GameTextUtil.GetText("unit_status17");
baseUnitInfo.Lv = string.Format(levelFormat, m_baseChara.m_CharaLevel, m_baseChara.m_CharaMasterDataParam.level_max);
MasterDataSkillLimitBreak lb_skill = MasterFinder <MasterDataSkillLimitBreak> .Instance.Find((int)m_baseChara.m_CharaMasterDataParam.skill_limitbreak);
baseUnitInfo.Slv = "-";
if (lb_skill != null)
{
baseUnitInfo.Slv = string.Format("{0}/{1}", m_baseChara.m_CharaLBSLv + 1, lb_skill.level_max + 1);
}
if (m_baseChara.m_CharaPlusHP != 0)
{
baseUnitInfo.Hp = string.Format(GameTextUtil.GetText("unit_status19"), m_baseChara.m_CharaHP, m_baseChara.m_CharaPlusHP);
}
else
{
baseUnitInfo.Hp = m_baseChara.m_CharaHP.ToString();
}
if (m_baseChara.m_CharaPlusPow != 0)
{
baseUnitInfo.Atk = string.Format(GameTextUtil.GetText("unit_status19"), m_baseChara.m_CharaPow, m_baseChara.m_CharaPlusPow);
}
else
{
baseUnitInfo.Atk = m_baseChara.m_CharaPow.ToString();
}
baseUnitInfo.Charm = string.Format(GameTextUtil.GetText("kyouka_text1"), m_baseChara.m_CharaCharm.ToString("F1"));
}
else
{
#if BUILD_TYPE_DEBUG
baseUnitInfo.Name = "<color=#FF0000>No MasterDataParamChara fix_id:" + m_baseChara.m_CharaMasterDataParam.fix_id + "</color>";
#endif
}
ViewScrollAlpha = 1;
}
private void setParam(CharaOnce baseChara, MasterDataParamChara _masterMain, MasterDataLimitOver _masterMainLO, MasterDataSkillLimitBreak _masterMainLB, PacketStructUnit _subUnit = null, CharaOnce prevUnit = null)
{
/**
* メインユニット情報
*/
{
string levelFormat = GameTextUtil.GetText("unit_status17");
Level = string.Format(levelFormat, baseChara.m_CharaLevel, _masterMain.level_max);
}
{
if (baseChara.m_CharaPlusHP != 0)
{
Hp = string.Format(GameTextUtil.GetText("unit_status19"), baseChara.m_CharaHP, baseChara.m_CharaPlusHP);
}
else
{
Hp = string.Format("{0}", baseChara.m_CharaHP);
}
}
{
if (baseChara.m_CharaPlusPow != 0)
{
Atk = string.Format(GameTextUtil.GetText("unit_status19"), baseChara.m_CharaPow, baseChara.m_CharaPlusPow);
}
else
{
Atk = string.Format("{0}", baseChara.m_CharaPow);
}
}
int _cost = _masterMain.party_cost;
if (_subUnit != null)
{
_cost += CharaLinkUtil.GetLinkUnitCost(_subUnit.id);
}
Cost = _cost.ToString();
Charm = baseChara.m_CharaCharm.ToString("F1");
int limitBreakSkill = 0;
int limitBreakSkillMax = 0;
if (_masterMainLB != null)
{
limitBreakSkill = baseChara.m_CharaLBSLv + 1;
limitBreakSkillMax = _masterMainLB.level_max + 1;
}
Aslv = limitBreakSkill.ToString();
AslvMax = limitBreakSkillMax.ToString();
Lo = baseChara.m_CharaLimitOver.ToString();
LoMax = _masterMainLO.limit_over_max.ToString();
if (prevUnit != null)
{
if (baseChara.m_CharaHP > prevUnit.m_CharaHP)
{
Hp = string.Format(GameTextUtil.GetText("kyouka_text1"), Hp);
}
if (baseChara.m_CharaPow > prevUnit.m_CharaPow)
{
Atk = string.Format(GameTextUtil.GetText("kyouka_text1"), Atk);
}
if (_cost > prevUnit.m_CharaMasterDataParam.party_cost)
{
Cost = string.Format(GameTextUtil.GetText("kyouka_text1"), Cost);
}
if (baseChara.m_CharaCharm > prevUnit.m_CharaCharm)
{
Charm = string.Format(GameTextUtil.GetText("kyouka_text1"), baseChara.m_CharaCharm.ToString("F1"));
}
}
}
//----------------------------------------------------------------------------
/*!
* @brief ステータス更新
* @note
*/
//----------------------------------------------------------------------------
void SetupBlendAfterStatus()
{
//-----------------------
// 必要資金の算出
//-----------------------
m_BlendMoney = 0;
m_BlendMoney += (m_CharaEvol != null) ? m_CharaEvol.money : 0;
//-----------------------
// 合成時のパラメータ数値表示部分を更新
//-----------------------
if (m_BaseUnit != null &&
m_CharaEvol != null)
{
MasterDataParamChara cCharaMasterData = MasterDataUtil.GetCharaParamFromID(m_BaseUnit.id);
MasterDataParamChara cCharaMasterDataAfter = MasterDataUtil.GetCharaParamFromID(m_CharaEvol.unit_id_after);
if (cCharaMasterData != null &&
cCharaMasterDataAfter != null
)
{
//----------------------------------------
// 初心者ブースト適用
// 表示用の値を計算、補正値を適用
//
// ※費用倍率が１倍の場合は表示反映しない
//----------------------------------------
if (MainMenuParam.m_BeginnerBoost != null &&
MainMenuParam.m_BeginnerBoost.boost_build_money != 100
)
{
m_BlendMoney = MasterDataUtil.ConvertBeginnerBoostBuildMoney(ref MainMenuParam.m_BeginnerBoost, m_BlendMoney);
}
m_UnitBGPanel.Money = (int)m_BlendMoney;
}
uint plus_pow = m_BaseUnit.add_pow;
uint plus_hp = m_BaseUnit.add_hp;
for (int i = 0; i < m_UnitMaterialPanel.MaterialList.Count; i++)
{
if (m_UnitMaterialPanel.MaterialList[i].m_UniqueId == 0)
{
continue;
}
PacketStructUnit unit = UserDataAdmin.Instance.SearchChara(m_UnitMaterialPanel.MaterialList[i].m_UniqueId);
if (unit == null)
{
continue;
}
plus_pow += unit.add_pow;
plus_hp += unit.add_hp;
}
//プラス値最大チェック
if (plus_pow > GlobalDefine.PLUS_MAX)
{
plus_pow = GlobalDefine.PLUS_MAX;
}
if (plus_hp > GlobalDefine.PLUS_MAX)
{
plus_hp = GlobalDefine.PLUS_MAX;
}
//進化後パラメータ
m_UnitStatusPanel.setupChara(m_AfterCharaMaster.fix_id, UnitStatusPanel.StatusType.LV_1, m_BaseUnit.limitover_lv, plus_pow, plus_hp);
// 進化後パラメータはLv1のステータスが設定されるため、ActiveSkillLvをベースユニットから引き継いで設定する.
uint activeSkillLv = 0;
int activeSkillLvMax = 0;
if (cCharaMasterDataAfter.skill_limitbreak != 0)
{
if (cCharaMasterData.skill_limitbreak == cCharaMasterDataAfter.skill_limitbreak)
{
//進化後も同じスキルの場合はLVを引き継ぐ
activeSkillLv = m_BaseUnit.limitbreak_lv + 1;
}
else
{
//進化後のスキルが違う場合は１にする。
activeSkillLv = 1;
}
MasterDataSkillLimitBreak cMasterSkillLimitBreak = MasterDataUtil.GetLimitBreakSkillParamFromID(cCharaMasterDataAfter.skill_limitbreak);
activeSkillLvMax = cMasterSkillLimitBreak.level_max + 1;
}
m_UnitStatusPanel.Aslv = string.Format(GameTextUtil.GetText("unit_status15"), activeSkillLv);
m_UnitStatusPanel.AslvMax = string.Format(GameTextUtil.GetText("unit_status15"), activeSkillLvMax);
}
}
//----------------------------------------------------------------------------
/*!
* @brief ステータス更新
* @note
*/
//----------------------------------------------------------------------------
void SetupBlendAfterStatus()
{
//-----------------------
// 必要ポイントの算出
//-----------------------
m_BlendPoint = 0;
m_BlendPoint += (m_BaseCharaMaster != null) ? (uint)m_BaseCharaMaster.evol_unitpoint : 0;
//-----------------------
// 合成時のパラメータ数値表示部分を更新
//-----------------------
if (m_BaseUnit != null &&
m_CharaEvol != null)
{
MasterDataParamChara cCharaMasterData = MasterDataUtil.GetCharaParamFromID(m_BaseUnit.id);
MasterDataParamChara cCharaMasterDataAfter = MasterDataUtil.GetCharaParamFromID(m_CharaEvol.unit_id_after);
if (cCharaMasterData != null &&
cCharaMasterDataAfter != null
)
{
m_UnitBGPanel.Point = (int)m_BlendPoint;
}
uint plus_pow = m_BaseUnit.add_pow;
uint plus_hp = m_BaseUnit.add_hp;
//プラス値最大チェック
if (plus_pow > GlobalDefine.PLUS_MAX)
{
plus_pow = GlobalDefine.PLUS_MAX;
}
if (plus_hp > GlobalDefine.PLUS_MAX)
{
plus_hp = GlobalDefine.PLUS_MAX;
}
//進化後パラメータ
m_UnitStatusPanel.setupChara(m_AfterCharaMaster.fix_id, UnitStatusPanel.StatusType.LV_1, m_BaseUnit.limitover_lv, plus_pow, plus_hp);
// 進化後パラメータはLv1のステータスが設定されるため、ActiveSkillLvをベースユニットから引き継いで設定する.
uint activeSkillLv = 0;
int activeSkillLvMax = 0;
if (cCharaMasterDataAfter.skill_limitbreak != 0)
{
if (cCharaMasterData.skill_limitbreak == cCharaMasterDataAfter.skill_limitbreak)
{
//進化後も同じスキルの場合はLVを引き継ぐ
activeSkillLv = m_BaseUnit.limitbreak_lv + 1;
}
else
{
//進化後のスキルが違う場合は１にする。
activeSkillLv = 1;
}
MasterDataSkillLimitBreak cMasterSkillLimitBreak = MasterDataUtil.GetLimitBreakSkillParamFromID(cCharaMasterDataAfter.skill_limitbreak);
activeSkillLvMax = cMasterSkillLimitBreak.level_max + 1;
}
m_UnitStatusPanel.Aslv = string.Format(GameTextUtil.GetText("unit_status15"), activeSkillLv);
m_UnitStatusPanel.AslvMax = string.Format(GameTextUtil.GetText("unit_status15"), activeSkillLvMax);
}
}
