/// <summary>
/// パッシブスキル設定
/// </summary>
/// <param name="skill_id"></param>
public void setupPassiveSkill(uint skill_id)
{
BaseHeight = BASE_DEFAULT_HEIGHT;
TitleHeight = TITLE_DEFAULT_HEIGHT;
TitleWidth = TITLE_DEFAULT_WIDTH;
MessageBgH = MESSAGE_BG_HEIGHT;
TitleBGImage = ResourceManager.Instance.Load("skill_name_bg3", ResourceType.Common);
SkillTitleImage = ResourceManager.Instance.Load("Unit_PASSIVE", ResourceType.Common);
IsViewElement = false;
IsViewTurn = false;
IsViewSkillLevel = false;
IsTurnLabelBlackColor = false;
IsSkillItem = true;
IsViewIcon = false;
IsViewStatus = false;
MasterDataSkillPassive _master = MasterFinder <MasterDataSkillPassive> .Instance.Find((int)skill_id);
if (_master == null)
{
return;
}
SkillTitleText = _master.name;
SkillDetailText = _master.detail;
MessageBgResize();
}
// 指定HANDSでHP回復情報を取得
public HandsHealInfo Get_HandsHealInfo()
{
MasterDataSkillPassive wrk_master = this;
while (wrk_master != null)
{
if (wrk_master.skill_type == MasterDataDefineLabel.PassiveSkillCategory.HANDS_HEAL)
{
HandsHealInfo ret_val = new HandsHealInfo();
ret_val.m_IsOver = wrk_master._Get_HANDS_HE_OVER();
ret_val.m_HandsCount = wrk_master._Get_HANDS_HE_COUNT();
if (wrk_master._Get_HANDS_HE_VALUE_ACTIVE())
{
ret_val.m_HealValuePercent = 0;
ret_val.m_HealValueFix = wrk_master._Get_HANDS_HE_VALUE();
}
else
{
ret_val.m_HealValuePercent = wrk_master._Get_HANDS_HE_VALUE();
ret_val.m_HealValueFix = 0;
}
return(ret_val);
}
wrk_master = BattleParam.m_MasterDataCache.useSkillPassive((uint)wrk_master.add_fix_id);
}
return(null);
}
public void SetLinkEffectSkill(MasterDataParamChara cCharaMasterData, uint nLinkPoint)
{
//------------------------------------------------------------
// LINK SKILL
//------------------------------------------------------------
MasterDataSkillActive cSkillParamLinkActive = null;
if (cCharaMasterData != null)
{
cSkillParamLinkActive = MasterDataUtil.GetActiveSkillParamFromID(cCharaMasterData.link_skill_active);
}
if (null != cSkillParamLinkActive)
{
// スキル名
LinkSkillName = cSkillParamLinkActive.skill_link_name;
// 説明文
LinkSkillMessage = cSkillParamLinkActive.skill_link_detail;
//発動率
float fSkillOdds = CharaLinkUtil.GetLinkSkillOdds(cSkillParamLinkActive, (int)nLinkPoint) * 0.01f;
LinkSkillRate = string.Format(GameTextUtil.GetText("unit_linkstatus2"), fSkillOdds.ToString("F1"));
}
else
{
// スキル名
LinkSkillName = EmptyStr;
// 説明文
LinkSkillMessage = EmptyStr;
// 発動率
LinkSkillRate = "";
}
//------------------------------------------------------------
// LINK PASSIVE
//------------------------------------------------------------
MasterDataSkillPassive cSkillParamLinkPassive = null;
if (cCharaMasterData != null)
{
cSkillParamLinkPassive = MasterDataUtil.GetPassiveSkillParamFromID(cCharaMasterData.link_skill_passive);
}
if (null != cSkillParamLinkPassive)
{
// スキル名
LinkPassiveName = cSkillParamLinkPassive.name;
// 説明文
LinkPassiveMessage = cSkillParamLinkPassive.detail;
}
else
{
// スキル名
LinkPassiveName = EmptyStr;
// 説明文
LinkPassiveMessage = EmptyStr;
}
}
/// <summary>
/// スキル効果を適用
/// </summary>
/// <param name="passive_skill_master"></param>
/// <param name="member_index"></param>
/// <param name="is_link_member"></param>
/// <param name="dest_param_ai"></param>
public void applySkill(MasterDataSkillPassive passive_skill_master, GlobalDefine.PartyCharaIndex member_index, bool is_link_member)
{
for (MasterDataDefineLabel.AutoPlaySkillType skill_type = MasterDataDefineLabel.AutoPlaySkillType.NONE + 1; skill_type < MasterDataDefineLabel.AutoPlaySkillType.MAX; skill_type++)
{
bool is_exist = passive_skill_master.Check_AutoPlaySkillType(skill_type);
if (is_exist)
{
applySkill(skill_type, member_index, is_link_member);
}
}
}
// 指定したタイプのオートプレイスキルを持っているかどうか
public bool Check_AutoPlaySkillType(MasterDataDefineLabel.AutoPlaySkillType skill_type)
{
MasterDataSkillPassive wrk_master = this;
while (wrk_master != null)
{
if (wrk_master._Get_AutoPlaySkillType() == skill_type)
{
return(true);
}
wrk_master = BattleParam.m_MasterDataCache.useSkillPassive((uint)wrk_master.add_fix_id);
}
return(false);
}
// バックアタック情報を取得
public BackAttackInfo Get_BackAttackInfo()
{
MasterDataSkillPassive wrk_master = this;
while (wrk_master != null)
{
if (wrk_master._Is_skill_backatk_pass_active())
{
BackAttackInfo ret_val = new BackAttackInfo();
ret_val.m_BackAttackPercent = wrk_master.skill_backatk_pass_rate;
return(ret_val);
}
wrk_master = BattleParam.m_MasterDataCache.useSkillPassive((uint)wrk_master.add_fix_id);
}
return(null);
}
// 根性（ふんばり・即死回避）情報を取得
public FunbariInfo Get_FunbariInfo()
{
MasterDataSkillPassive wrk_master = this;
while (wrk_master != null)
{
if (wrk_master.skill_type == MasterDataDefineLabel.PassiveSkillCategory.GUARD_FUNBARI)
{
FunbariInfo ret_val = new FunbariInfo();
ret_val.m_HpBorder = wrk_master._Get_GUARD_FUNBARI_BORDER();
return(ret_val);
}
wrk_master = BattleParam.m_MasterDataCache.useSkillPassive((uint)wrk_master.add_fix_id);
}
return(null);
}
// フルライフアタック情報（体力最大時攻撃力アップ効果）を取得
public FullLifeAttacUpkInfo Get_FullLifeAttackUpInfo()
{
MasterDataSkillPassive wrk_master = this;
while (wrk_master != null)
{
if (wrk_master._Is_skill_hp_full_powup_active())
{
FullLifeAttacUpkInfo ret_val = new FullLifeAttacUpkInfo();
ret_val.m_AttackPercent = wrk_master.skill_hp_full_powup_scale;
return(ret_val);
}
wrk_master = BattleParam.m_MasterDataCache.useSkillPassive((uint)wrk_master.add_fix_id);
}
return(null);
}
// カウントダウン秒数の増減情報を取得
public CountDownTimeInfo Get_CountDownTimeInfo()
{
MasterDataSkillPassive wrk_master = this;
while (wrk_master != null)
{
if (wrk_master.skill_type == MasterDataDefineLabel.PassiveSkillCategory.COUNTDOWN)
{
CountDownTimeInfo ret_val = new CountDownTimeInfo();
ret_val.m_Second = wrk_master._Get_COUNTDOWN_SECOND();
return(ret_val);
}
wrk_master = BattleParam.m_MasterDataCache.useSkillPassive((uint)wrk_master.add_fix_id);
}
return(null);
}
// 指定HANDS以上でダメージUP情報を取得
public HandsAttackUpInfo Get_HandsAttackUpInfo()
{
MasterDataSkillPassive wrk_master = this;
while (wrk_master != null)
{
if (wrk_master.skill_type == MasterDataDefineLabel.PassiveSkillCategory.DMGUP_HANDS_NUM)
{
HandsAttackUpInfo ret_val = new HandsAttackUpInfo();
ret_val.m_HandsCount = wrk_master._Get_DMGUP_HANDS_NUM_CNT();
ret_val.m_AttackPercent = wrk_master._Get_DMGUP_HANDS_NUM_SCALE();
return(ret_val);
}
wrk_master = BattleParam.m_MasterDataCache.useSkillPassive((uint)wrk_master.add_fix_id);
}
return(null);
}
// 底力（瀕死時攻撃力アップ）情報を取得
public DyingAttackUpInfo Get_DyingAttackUpInfo()
{
MasterDataSkillPassive wrk_master = this;
while (wrk_master != null)
{
if (wrk_master._Is_skill_dying_powup_active())
{
DyingAttackUpInfo ret_val = new DyingAttackUpInfo();
ret_val.m_AttackPercent = wrk_master.skill_dying_powup_scale;
ret_val.m_HpBorder = wrk_master.skill_dying_powup_border;
return(ret_val);
}
wrk_master = BattleParam.m_MasterDataCache.useSkillPassive((uint)wrk_master.add_fix_id);
}
return(null);
}
// 追撃効果の情報を取得
public FollowAttackInfo Get_FollowAttackInfo()
{
MasterDataSkillPassive wrk_master = this;
while (wrk_master != null)
{
if (wrk_master.skill_type == MasterDataDefineLabel.PassiveSkillCategory.FOLLOW_ATK)
{
FollowAttackInfo ret_val = new FollowAttackInfo();
ret_val.m_AttackPercent = wrk_master._Get_FOLLOW_ATK_SCALE();
ret_val.m_ElementType = wrk_master._Get_FOLLOW_ATK_ELEM();
ret_val.m_EffectType = wrk_master._Get_FOLLOW_ATK_EFFECT();
return(ret_val);
}
wrk_master = BattleParam.m_MasterDataCache.useSkillPassive((uint)wrk_master.add_fix_id);
}
return(null);
}
// 属性ダメージ軽減情報を取得
public DeclineElementDamageInfo Get_DeclineElementDamageInfo(MasterDataDefineLabel.ElementType element_type)
{
// 個別属性指定と全属性が同時に存在するときは個別属性指定を優先する
{
MasterDataSkillPassive wrk_master = this;
while (wrk_master != null)
{
if (wrk_master._Is_skill_decline_dmg_elem_active() &&
element_type == wrk_master.skill_decline_dmg_elem_elem
)
{
DeclineElementDamageInfo ret_val = new DeclineElementDamageInfo();
ret_val.m_DamagePercent = wrk_master.skill_decline_dmg_elem_rate;
return(ret_val);
}
wrk_master = BattleParam.m_MasterDataCache.useSkillPassive((uint)wrk_master.add_fix_id);
}
}
// 全属性（マスターデータに属性指定が無いものは全属性に対して効果あり）
{
MasterDataSkillPassive wrk_master = this;
while (wrk_master != null)
{
if (wrk_master._Is_skill_decline_dmg_elem_active() &&
MasterDataDefineLabel.ElementType.NONE == wrk_master.skill_decline_dmg_elem_elem
)
{
DeclineElementDamageInfo ret_val = new DeclineElementDamageInfo();
ret_val.m_DamagePercent = wrk_master.skill_decline_dmg_elem_rate;
return(ret_val);
}
wrk_master = BattleParam.m_MasterDataCache.useSkillPassive((uint)wrk_master.add_fix_id);
}
}
return(null);
}
// 種族ダメージ軽減情報を取得
public DeclineKindDamageInfo Get_DeclineKindDamageInfo(MasterDataDefineLabel.KindType kind_type)
{
// 個別種族指定と全種族が同時に存在するときは個別種族指定を優先する
{
MasterDataSkillPassive wrk_master = this;
while (wrk_master != null)
{
if (wrk_master._Is_skill_decline_dmg_kind_active() &&
kind_type == wrk_master.skill_decline_dmg_kind_kind
)
{
DeclineKindDamageInfo ret_val = new DeclineKindDamageInfo();
ret_val.m_DamagePercent = wrk_master.skill_decline_dmg_kind_rate;
return(ret_val);
}
wrk_master = BattleParam.m_MasterDataCache.useSkillPassive((uint)wrk_master.add_fix_id);
}
}
// 全種族（マスターデータに種族指定が無いものは全種族に対して効果あり）
{
MasterDataSkillPassive wrk_master = this;
while (wrk_master != null)
{
if (wrk_master._Is_skill_decline_dmg_kind_active() &&
MasterDataDefineLabel.KindType.NONE == wrk_master.skill_decline_dmg_kind_kind
)
{
DeclineKindDamageInfo ret_val = new DeclineKindDamageInfo();
ret_val.m_DamagePercent = wrk_master.skill_decline_dmg_kind_rate;
return(ret_val);
}
wrk_master = BattleParam.m_MasterDataCache.useSkillPassive((uint)wrk_master.add_fix_id);
}
}
return(null);
}
/// <summary>
/// リンクパッシブ設定
/// </summary>
/// <param name="skill_id"></param>
public void setupLinkPassive(MasterDataParamChara cCharaMasterData)
{
BaseHeight = BASE_DEFAULT_HEIGHT;
TitleHeight = TITLE_DEFAULT_HEIGHT;
TitleWidth = LINK_PASSIVE_TITLE_WIDTH;
MessageBgH = MESSAGE_BG_HEIGHT;
setLinkTitleImage("skill_name_bg4", "LINK PASSIVE");
IsSkillItem = false;
IsViewStatus = false;
IsViewIcon = false;
//------------------------------------------------------------
// LINK PASSIVE
//------------------------------------------------------------
MasterDataSkillPassive cSkillParamLinkPassive = null;
if (cCharaMasterData != null)
{
cSkillParamLinkPassive = MasterDataUtil.GetPassiveSkillParamFromID(cCharaMasterData.link_skill_passive);
}
if (null != cSkillParamLinkPassive)
{
// スキル名
LinkTitleText = cSkillParamLinkPassive.name;
// 説明文
SkillDetailText = cSkillParamLinkPassive.detail;
}
else
{
// スキル名
LinkTitleText = EmptyStr;
// 説明文
SkillDetailText = EmptyStr;
}
MessageBgResize();
}
/**
* プレイヤー側で使用しているマスターデータをキャッシュ.
*/
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);
}
}
}
}
}
//----------------------------------------------------------------------------
/*!
@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;
}
private void setSkillInfo()
{
int panel_put_count_base = PANEL_PUT_COUNT_BASE;
#if BUILD_TYPE_DEBUG
// パネル配置数をデバッグメニューの値で上書き
{
int debug_panel_put_count = BattleDebugMenu.getAutoPlayPanelPutCount();
if (debug_panel_put_count > 0)
{
panel_put_count_base = debug_panel_put_count;
}
}
#endif //BUILD_TYPE_DEBUG
m_SkillWorksInfo.init(panel_put_count_base);
// オートプレイスキルの効果を集約
bool is_applied_ailment = false;
for (int member_idx = 0; member_idx < MEMBER_ORDER.Length; member_idx++)
{
GlobalDefine.PartyCharaIndex member_type = MEMBER_ORDER[member_idx];
CharaOnce chara_once = BattleParam.m_PlayerParty.getPartyMember(member_type, CharaParty.CharaCondition.SKILL_PASSIVE);
if (chara_once != null)
{
#if BUILD_TYPE_DEBUG
// デバッグメニューで設定されたスキルを適用
{
MasterDataDefineLabel.AutoPlaySkillType[] debug_skills = BattleDebugMenu.getAutoPlaySkill(member_type);
if (debug_skills.IsNullOrEmpty() == false)
{
for (int debug_skill_idx = 0; debug_skill_idx < debug_skills.Length; debug_skill_idx++)
{
MasterDataDefineLabel.AutoPlaySkillType debug_skill_type = debug_skills[debug_skill_idx];
m_SkillWorksInfo.applySkill(debug_skill_type, member_type, false);
}
}
}
#endif //BUILD_TYPE_DEBUG
// メインユニットのパッシブスキル
{
MasterDataSkillPassive passive_skill_master = BattleParam.m_MasterDataCache.useSkillPassive(chara_once.m_CharaMasterDataParam.skill_passive);
if (passive_skill_master != null)
{
m_SkillWorksInfo.applySkill(passive_skill_master, member_type, false);
}
}
// リンクユニットのパッシブスキル
if (chara_once.m_LinkParam != null &&
chara_once.m_LinkParam.m_CharaID != 0
)
{
MasterDataParamChara link_chara_master = BattleParam.m_MasterDataCache.useCharaParam(chara_once.m_LinkParam.m_CharaID);
if (link_chara_master != null)
{
MasterDataSkillPassive link_passive_skill_master = BattleParam.m_MasterDataCache.useSkillPassive(link_chara_master.link_skill_passive);
if (link_passive_skill_master != null)
{
m_SkillWorksInfo.applySkill(link_passive_skill_master, member_type, true);
}
}
}
// 状態異常にあるオートプレイ用スキルを反映
if (is_applied_ailment == false)
{
is_applied_ailment = true;
StatusAilmentChara status_ailment_chara = BattleParam.m_PlayerParty.m_Ailments.getAilment(member_type);
if (status_ailment_chara != null)
{
for (int ailment_idx = 0; ailment_idx < status_ailment_chara.GetAilmentCount(); ailment_idx++)
{
StatusAilment status_ailment = status_ailment_chara.GetAilment(ailment_idx);
if (status_ailment != null)
{
if (status_ailment.nType == MasterDataDefineLabel.AilmentType.AUTO_PLAY_SKILL)
{
MasterDataStatusAilmentParam ailment_param = BattleParam.m_MasterDataCache.useAilmentParam((uint)status_ailment.nMasterDataStatusAilmentID);
if (ailment_param != null)
{
MasterDataDefineLabel.AutoPlaySkillType auto_play_skill_type = ailment_param.Get_AUTO_PLAY_SKILL_TYPE();
m_SkillWorksInfo.applySkill(auto_play_skill_type, member_type, false);
}
}
}
}
}
}
}
}
m_SkillWorksInfo.fix();
}
