//----------------------------------------------------------------------------
/*!
* @brief リンクシステム：リンクユニットIDの取得(キャラカットイン用に特化)
* @param[in] BattleSkillActivity (cActivity) 戦闘時スキル発動情報
* @return uint [キャラID]
* @note パーティキャラから、リンクユニットのキャラIDを取得
*/
//----------------------------------------------------------------------------
static public uint GetCutinLinkUnitID(BattleSkillActivity cActivity)
{
uint unResult = 0;
//--------------------------------
// エラーチェック
//--------------------------------
if (cActivity == null)
{
return(unResult);
}
//--------------------------------
// スキルタイプによる分岐
//--------------------------------
switch (cActivity.m_SkillType)
{
case ESKILLTYPE.eLINK:
case ESKILLTYPE.eLINKPASSIVE:
unResult = GetLinkUnitID(cActivity.m_SkillParamOwnerNum);
break;
case ESKILLTYPE.eACTIVE:
case ESKILLTYPE.eLEADER:
case ESKILLTYPE.ePASSIVE:
case ESKILLTYPE.eLIMITBREAK:
case ESKILLTYPE.eBOOST:
default:
break;
}
return(unResult);
}
public void SetSkillCutin(SkillRequestParam skillRequest)
{
for (int idx = 0; idx < skillRequest.getRequestCount(); idx++)
{
BattleSkillActivity skill_activity = skillRequest.getSkillRequestByIndex(idx);
SetSkillCutin(skill_activity);
}
m_SkillRequestParam = skillRequest;
}
private static BattleSkillActivity getLeaderSkillActivity(GlobalDefine.PartyCharaIndex charaIdx, CharaParty PlayerParty)
{
BattleSkillActivity activity = new BattleSkillActivity();
if (activity == null)
{
return(null);
}
if (charaIdx < 0 || charaIdx >= GlobalDefine.PartyCharaIndex.MAX)
{
return(null);
}
if (PlayerParty == null)
{
return(null);
}
// パーティリーダーキャラ情報を取得
CharaOnce chara = PlayerParty.getPartyMember(charaIdx, CharaParty.CharaCondition.EXIST);
if (chara == null)
{
return(null);
}
if (chara == null)
{
return(null);
}
if (!chara.m_bHasCharaMasterDataParam)
{
return(null);
}
MasterDataSkillLeader skill = BattleParam.m_MasterDataCache.useSkillLeader(chara.m_CharaMasterDataParam.skill_leader);
if (skill == null)
{
return(null);
}
//--------------------------------------------------------------------
// スキル発動情報設定
//--------------------------------------------------------------------
activity.m_SkillParamOwnerNum = charaIdx;
activity.m_SkillParamFieldID = 0;
activity.m_SkillParamSkillID = chara.m_CharaMasterDataParam.skill_leader;
activity.m_SkillType = ESKILLTYPE.eLEADER;
return(activity);
}
//----------------------------------------------------------------------------
/*!
* @brief 手札変換：パネル指定
*/
//----------------------------------------------------------------------------
public void ChangeHandPanel(BattleSkillActivity activity)
{
//------------------------------
// エラーチェック
//------------------------------
if (activity == null ||
BattleParam.isActiveBattle() == false)
{
return;
}
// バトルマネージャ取得
BattleSceneManager battleMgr = BattleSceneManager.Instance;
// 汎用パラメータから設定
MasterDataDefineLabel.ElementType[] elemArray = activity.Get_BOOSTSKILL_HAND_CNG_PANEL();
for (int i = 0; i < elemArray.Length; ++i)
{
BattleScene.BattleCard battle_card = battleMgr.PRIVATE_FIELD.m_BattleCardManager.m_HandArea.getCard(i);
if (battle_card == null ||
elemArray[i] == MasterDataDefineLabel.ElementType.MAX)
{
continue;
}
// 変換先が設定されている場合
if (elemArray[i] != MasterDataDefineLabel.ElementType.NONE)
{
// 属性変更
battle_card.setElementType(elemArray[i], BattleScene.BattleCard.ChangeCause.SKILL);
// 手札変化エフェクト
BattleSceneManager.Instance.PRIVATE_FIELD.m_BattleCardManager.addEffectInfo(BattleScene._BattleCardManager.EffectInfo.EffectPosition.HAND_CARD_AREA, i, BattleScene._BattleCardManager.EffectInfo.EffectType.CARD_CHANGE);
// 設定されていない場合は、ランダム変換
}
else
{
// ランダム属性を取得
MasterDataDefineLabel.ElementType randElement = (MasterDataDefineLabel.ElementType)RandManager.GetRand((int)MasterDataDefineLabel.ElementType.NAUGHT,
(int)MasterDataDefineLabel.ElementType.MAX);
// 属性変更
battle_card.setElementType(randElement, BattleScene.BattleCard.ChangeCause.SKILL);
// 手札変化エフェクト
BattleSceneManager.Instance.PRIVATE_FIELD.m_BattleCardManager.addEffectInfo(BattleScene._BattleCardManager.EffectInfo.EffectPosition.HAND_CARD_AREA, i, BattleScene._BattleCardManager.EffectInfo.EffectType.CARD_CHANGE);
}
}
}
private void SetSkillCutin(BattleSkillActivity cBattleSkillActivity)
{
if (cBattleSkillActivity != null)
{
string skill_name = cBattleSkillActivity.getMainText();
ESKILLTYPE skill_type = cBattleSkillActivity.m_SkillType;
MasterDataDefineLabel.ElementType skill_element = cBattleSkillActivity.m_Element;
int id = m_NewBattleSkillCutin.addSkill(cBattleSkillActivity.m_SkillParamOwnerNum, skill_name, skill_type, skill_element, cBattleSkillActivity.m_SkillIndex);
cBattleSkillActivity.m_CutinID = id;
}
}
private static BattleSkillActivity getSkillActivity(GlobalDefine.PartyCharaIndex charaIdx, uint skillID, ESKILLTYPE skillType)
{
BattleSkillActivity activity = new BattleSkillActivity();
//--------------------------------
// スキル情報を設定
//--------------------------------
activity.m_SkillParamOwnerNum = charaIdx;
activity.m_SkillParamFieldID = 0;
activity.m_SkillParamSkillID = skillID;
activity.m_SkillType = skillType;
return(activity);
}
//----------------------------------------------------------------------------
/*!
* @brief LBS必要ターン数の短縮
* @param[in] BattleSkillActivity (activity) スキル発動情報
*/
//----------------------------------------------------------------------------
public void ReduceLBSTurn(BattleSkillActivity activity)
{
if (activity == null)
{
return;
}
// スキルパラメータ取得
GlobalDefine.PartyCharaIndex userID = activity.m_SkillParamOwnerNum;
int turn = activity.Get_BOOSTSKILL_LBS_TURN_REDUCE_VALUE();
MasterDataDefineLabel.TargetType target = activity.Get_BOOSTSKILL_LBS_TURN_REDUCE_TARGET();
// 対象情報による分岐
CharaOnce chara;
switch (target)
{
// 発動者のみ
case MasterDataDefineLabel.TargetType.SELF:
// エラーチェック
chara = BattleParam.m_PlayerParty.getPartyMember(userID, CharaParty.CharaCondition.SKILL_TURN1);
if (chara == null)
{
break;
}
// LBS必要ターン数短縮
chara.AddCharaLimitBreak(turn);
break;
case MasterDataDefineLabel.TargetType.FRIEND: // 発動者の味方全員
case MasterDataDefineLabel.TargetType.ALL: // 全員
case MasterDataDefineLabel.TargetType.SELF_OTHER_FRIEND: // 発動者以外の味方全員
case MasterDataDefineLabel.TargetType.SELF_OTHER_ALL: // 発動者以外の全員
for (int num = 0; num < (int)GlobalDefine.PartyCharaIndex.MAX; ++num)
{
// 発動者は効果適用外
if ((GlobalDefine.PartyCharaIndex)num == userID)
{
if (target == MasterDataDefineLabel.TargetType.SELF_OTHER_FRIEND ||
target == MasterDataDefineLabel.TargetType.SELF_OTHER_ALL)
{
continue;
}
}
// エラーチェック
chara = BattleParam.m_PlayerParty.getPartyMember((GlobalDefine.PartyCharaIndex)num, CharaParty.CharaCondition.SKILL_TURN1);
if (chara == null)
{
continue;
}
// LBS必要ターン数短縮
chara.AddCharaLimitBreak(turn);
}
break;
// 何も処理しない
case MasterDataDefineLabel.TargetType.NONE:
case MasterDataDefineLabel.TargetType.OTHER:
case MasterDataDefineLabel.TargetType.ENEMY:
case MasterDataDefineLabel.TargetType.ENE_N_1:
case MasterDataDefineLabel.TargetType.ENE_1N_1:
case MasterDataDefineLabel.TargetType.ENE_R_N:
case MasterDataDefineLabel.TargetType.ENE_1_N:
default:
break;
}
}
/// <summary>
/// アクティブスキルからブーストスキルの発動情報を抽出し追加
/// </summary>
/// <param name="active_skill_activity"></param>
public void AddActivityBoostSkill(BattleSkillActivity active_skill_activity)
{
if (active_skill_activity == null ||
active_skill_activity.m_SkillType != ESKILLTYPE.eACTIVE)
{
return;
}
// ブーストパネルを未使用の場合
if (active_skill_activity.m_bBonusBoost == false)
{
return;
}
MasterDataSkillActive skillActiveParam = active_skill_activity.getMasterDataSkillActive();
if (skillActiveParam == null ||
skillActiveParam.skill_boost_id == 0)
{
return;
}
// ブーストスキル情報を取得
MasterDataSkillBoost skillBoostParam = BattleParam.m_MasterDataCache.useSkillBoost(skillActiveParam.skill_boost_id);
if (skillBoostParam == null)
{
return;
}
// ブーストスキルを構築
BattleSkillActivity boost_skill_activity = new BattleSkillActivity();
if (boost_skill_activity != null)
{
// 共通情報を設定
boost_skill_activity.m_SkillParamOwnerNum = active_skill_activity.m_SkillParamOwnerNum; // 発動者
boost_skill_activity.m_SkillParamFieldID = InGameDefine.SELECT_NONE; // フィールドID(ブーストパネルの判定にも使っている)
boost_skill_activity.m_SkillParamSkillID = skillActiveParam.skill_boost_id; // ブーストスキルID
boost_skill_activity.m_SkillName = skillActiveParam.Get_skill_boost_name(); // ブーストスキル名
boost_skill_activity.m_SkillType = ESKILLTYPE.eBOOST; // 発動スキルの種類
boost_skill_activity.m_Element = skillActiveParam.skill_boost_element; // 基本情報：属性
boost_skill_activity.m_Type = skillBoostParam.skill_type; // 基本情報：スキルタイプ
boost_skill_activity.m_Category_BoostSkillCategory_PROPERTY = skillBoostParam.skill_cate; // 基本情報：効果カテゴリ
boost_skill_activity.m_Effect = skillActiveParam.skill_boost_effect; // 基本情報：エフェクト
boost_skill_activity.m_skill_power = skillBoostParam.skill_power; // 攻撃情報：攻撃力(％)
boost_skill_activity.m_skill_power_fix = skillBoostParam.skill_power_fix; // 攻撃情報：攻撃力(固定)
boost_skill_activity.m_skill_power_hp_rate = skillBoostParam.skill_power_hp_rate; // 攻撃情報：攻撃力(対象HPの割合)
boost_skill_activity.m_skill_absorb = skillBoostParam.skill_absorb; // 攻撃情報：吸収量(％)
boost_skill_activity.m_skill_chk_atk_affinity = skillBoostParam.skill_chk_atk_affinity; // 効果情報：攻撃側：属性相性チェック
boost_skill_activity.m_skill_chk_atk_leader = skillBoostParam.skill_chk_atk_leader; // 効果情報：攻撃側：リーダースキルチェック
boost_skill_activity.m_skill_chk_atk_passive = skillBoostParam.skill_chk_atk_passive; // 効果情報：攻撃側：パッシブスキルチェック
boost_skill_activity.m_skill_chk_atk_ailment = skillBoostParam.skill_chk_atk_ailment; // 効果情報：攻撃側：状態変化チェック
boost_skill_activity.m_skill_chk_atk_combo = MasterDataDefineLabel.BoolType.DISABLE; // 攻撃情報：攻撃側：コンボレートの影響
boost_skill_activity.m_skill_chk_def_defence = skillBoostParam.skill_chk_def_defence; // 効果情報：防御側：防御無視チェック
boost_skill_activity.m_skill_chk_def_ailment = skillBoostParam.skill_chk_def_ailment; // 効果情報：防御側：状態変化チェック
boost_skill_activity.m_skill_chk_def_barrier = skillBoostParam.skill_chk_def_barrier; // 効果情報：防御側：状態バリアチェック
boost_skill_activity.m_statusAilment_target = skillBoostParam.status_ailment_target; // 状態変化対象
boost_skill_activity.m_statusAilment = new int[] { skillBoostParam.status_ailment1, // 状態変化1
skillBoostParam.status_ailment2, // 状態変化2
skillBoostParam.status_ailment3, // 状態変化3
skillBoostParam.status_ailment4 }; // 状態変化4
boost_skill_activity.m_nStatusAilmentDelay = skillBoostParam.status_ailment_delay; // 状態変化遅延。
// 汎用情報を設定
boost_skill_activity._setParam(skillBoostParam);
// リストに登録
m_SkillRequestBoost.addSkillRequest(boost_skill_activity);
}
}
/// <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 bool m_bDelayAilment = false; //!< 遅延発動予約があるかどうか。
//---------------------------------------------------------------------
/**
* @brief 状態異常の遅延発動予約。
* @param[in] nCharaIndex : スキルを発動したキャラ。 ※BattleSkillActivity.m_SkillParamOwnerNum
* @param[in] acTarget : スキルのターゲット情報。 ※BattleSkillActivity.m_SkillParamTarget
* @param[in] nAilmentTarget : 状態異常ターゲット。 ※BattleSkillActivity.m_statusAilment_target
* @param[in] anAilment : 状態異常パラメータ配列。 ※BattleSkillActivity.m_statusAilment
*/
//---------------------------------------------------------------------
public void ReserveDelayAilment(GlobalDefine.PartyCharaIndex nCharaIndex, ref BattleSkillTarget[] acTarget, MasterDataDefineLabel.TargetType nAilmentTarget, ref int[] anAilmentID)
{
if (null == acTarget)
{
#if BUILD_TYPE_DEBUG
Debug.LogWarning("null == acTarget");
#endif // BUILD_TYPE_DEBUG
return;
}
if (null == anAilmentID)
{
#if BUILD_TYPE_DEBUG
Debug.LogWarning("null == anAilment");
#endif // BUILD_TYPE_DEBUG
return;
}
if (GlobalDefine.PartyCharaIndex.ERROR == nCharaIndex)
{
#if BUILD_TYPE_DEBUG
// ( -1 != m_SkillParamOwnerNum )を遅延発動の有無判定に使用するので、-1指定で予約されるのはエラー扱いとする。
Debug.LogError("-1 == nCharaIndex");
#endif // BUILD_TYPE_DEBUG
return;
}
//-----------------------------------------------------------------
// 遅延発動登録可能なバッファを探す。
//-----------------------------------------------------------------
int nIndex = -1;
int nLen = m_acDelayAilment.Length;
for (int i = 0; i < nLen; ++i)
{
if (null == m_acDelayAilment[i])
{
nIndex = i;
break;
}
}
if (nIndex < 0)
{
#if BUILD_TYPE_DEBUG
// 登録場所が見つからなかった。ターン毎にバッファがクリアされていないか、１ターンの総定数以上の遅延発動リクエストが来ているか。
Debug.LogWarning("ReserveDelayAilment failed. nIndex < 0");
#endif // BUILD_TYPE_DEBUG
return;
}
//-----------------------------------------------------------------
// １件でも予約が入っている場合、発動させる状態異常が重複していないかチェック。
// ※同じ種類の状態異常は先着優先となっているため、新しい状態異常がanAilmentに存在しない場合、この予約はキャンセルする。
//-----------------------------------------------------------------
if (m_bDelayAilment)
{
bool bNew = false;
nLen = m_acDelayAilment.Length;
for (int i = 0; i < nLen; ++i)
{
if (null == m_acDelayAilment[i])
{
continue;
}
if (!CheckAilmentDif(m_acDelayAilment[i].m_statusAilment,
m_acDelayAilment[i].m_statusAilment_target,
anAilmentID,
nAilmentTarget))
{
continue;
}
// 新しい状態異常がanAilmentに含まれている。予約処理に進む。
bNew = true;
break;
}
if (!bNew)
{
// 新しい状態異常が無い。予約不要。
return;
}
}
//-----------------------------------------------------------------
// 必要な情報を登録。
//-----------------------------------------------------------------
m_bDelayAilment = true;
m_acDelayAilment[nIndex] = new BattleSkillActivity();
m_acDelayAilment[nIndex].m_SkillParamTarget = new BattleSkillTarget[acTarget.Length];
m_acDelayAilment[nIndex].m_statusAilment = new int[anAilmentID.Length];
m_acDelayAilment[nIndex].m_SkillParamOwnerNum = nCharaIndex;
m_acDelayAilment[nIndex].m_statusAilment_target = nAilmentTarget;
nLen = m_acDelayAilment[nIndex].m_SkillParamTarget.Length;
for (int i = 0; i < nLen; ++i)
{
if (null != acTarget[i])
{
m_acDelayAilment[nIndex].m_SkillParamTarget[i] = new BattleSkillTarget(acTarget[i]);
}
}
nLen = m_acDelayAilment[nIndex].m_statusAilment.Length;
for (int i = 0; i < nLen; ++i)
{
m_acDelayAilment[nIndex].m_statusAilment[i] = anAilmentID[i];
}
}
//----------------------------------------------------------------------------
// @brief 状態異常処理
//----------------------------------------------------------------------------
public void SkillUpdate_StatusAilment(BattleSkillActivity activity, int nAtk, BattleSceneUtil.MultiInt nHPMax, BattleEnemy[] enemy_param)
{
if (activity == null ||
activity.m_SkillParamTarget == null ||
activity.m_statusAilment == null)
{
return;
}
bool clearOnAttack = true;
int statusAilment_data_id = 0;
MasterDataStatusAilmentParam statusAilmentParam = null;
BattleSkillTarget cBattleTarget = null;
BattleSceneManager battleMgr = BattleSceneManager.Instance;
if (battleMgr == null)
{
return;
}
// 発行された状態異常を全て処理する
for (int j = 0; j < activity.m_statusAilment.Length; j++)
{
statusAilment_data_id = activity.m_statusAilment[j];
if (statusAilment_data_id == 0)
{
continue;
}
statusAilmentParam = BattleParam.m_MasterDataCache.useAilmentParam((uint)statusAilment_data_id);
if (statusAilmentParam == null)
{
Debug.LogError("statusAilment Param not found.");
continue;
}
// 遅延のスキルは全員の効果がきれるまで再度この効果をかけることが出来ない
if (statusAilmentParam.category == MasterDataDefineLabel.AilmentType.FEAR)
{
for (int k = 0; k < enemy_param.Length; k++)
{
if (enemy_param[k] == null)
{
continue;
}
if (enemy_param[k].isDead() == true)
{
continue;
}
if (enemy_param[k].getAttackFlag() == true)
{
continue;
}
clearOnAttack = false;
}
}
// 誰かがまだ攻撃をしていない
if (clearOnAttack == false)
{
continue;
}
// 状態異常に設定されたターゲットをみて処理
switch (activity.m_statusAilment_target)
{
case MasterDataDefineLabel.TargetType.NONE:
default:
break;
case MasterDataDefineLabel.TargetType.FRIEND:
case MasterDataDefineLabel.TargetType.SELF:
//----------------------------------------
// プレイヤー側状態異常処理
//----------------------------------------
{
GlobalDefine.PartyCharaIndex target_player = GlobalDefine.PartyCharaIndex.MAX;
BattleParam.m_PlayerParty.m_Ailments.AddStatusAilmentToPlayerParty(target_player, statusAilment_data_id, nAtk, nHPMax);
}
break;
case MasterDataDefineLabel.TargetType.OTHER:
//----------------------------------------
// 敵単体(スキル側で指定されたターゲット)
//----------------------------------------
{
bool ailmentAddResult = false;
for (int i = 0; i < activity.m_SkillParamTarget.Length; i++)
{
cBattleTarget = activity.m_SkillParamTarget[i];
if (cBattleTarget == null)
{
continue;
}
BattleEnemy enemyParam = enemy_param[cBattleTarget.m_TargetNum];
if (enemyParam == null)
{
continue;
}
if (enemyParam.isDead() == true)
{
continue;
}
// 状態異常処理
// @change Developer 2016/02/23 v330 毒[最大HP割合]対応
ailmentAddResult = enemyParam.m_StatusAilmentChara.AddStatusAilment(statusAilment_data_id, nAtk, enemyParam.m_EnemyHPMax, enemyParam.getMasterDataParamChara());
// NEXTのターンを加算(特殊処理)
// 上限数以上の場合、遅延効果が発動しないように修正 @20150512 Developer
if (statusAilmentParam.category == MasterDataDefineLabel.AilmentType.FEAR &&
ailmentAddResult == true)
{
int nTurn = (int)RandManager.GetRand((uint)statusAilmentParam.Get_ABSTATE_LATE_TURN_MIN(),
(uint)statusAilmentParam.Get_ABSTATE_LATE_TURN_MAX());
enemyParam.AddTurn(nTurn);
}
}
}
break;
case MasterDataDefineLabel.TargetType.ENEMY:
case MasterDataDefineLabel.TargetType.ENE_N_1:
case MasterDataDefineLabel.TargetType.ENE_1N_1:
case MasterDataDefineLabel.TargetType.ENE_R_N:
case MasterDataDefineLabel.TargetType.ENE_1_N:
//----------------------------------------
// 敵全体
//----------------------------------------
{
BattleEnemy enemyParam = null;
bool ailmentAddResult = false;
for (int k = 0; k < enemy_param.Length; k++)
{
enemyParam = enemy_param[k];
if (enemyParam == null)
{
continue;
}
if (enemyParam.isDead() == true)
{
continue;
}
// 状態異常処理
// @change Developer 2016/02/23 v330 毒[最大HP割合]対応
ailmentAddResult = enemyParam.m_StatusAilmentChara.AddStatusAilment(statusAilment_data_id, nAtk, enemyParam.m_EnemyHPMax, enemyParam.getMasterDataParamChara());
// NEXTのターンを加算(特殊処理)
// 上限数以上の場合、遅延効果が発動しないように修正 @20150512 Developer
if (statusAilmentParam.category == MasterDataDefineLabel.AilmentType.FEAR &&
ailmentAddResult == true)
{
int nTurn = (int)RandManager.GetRand((uint)statusAilmentParam.Get_ABSTATE_LATE_TURN_MIN(),
(uint)statusAilmentParam.Get_ABSTATE_LATE_TURN_MAX());
enemyParam.AddTurn(nTurn);
}
}
}
break;
case MasterDataDefineLabel.TargetType.ALL:
//----------------------------------------
// 全員
//----------------------------------------
{
// プレイヤー側状態異常処理
GlobalDefine.PartyCharaIndex target_player = GlobalDefine.PartyCharaIndex.MAX;
BattleParam.m_PlayerParty.m_Ailments.AddStatusAilmentToPlayerParty(target_player, statusAilment_data_id, nAtk, nHPMax);
BattleEnemy enemyParam = null;
bool ailmentAddResult = false;
// 敵全体
for (int k = 0; k < enemy_param.Length; k++)
{
enemyParam = enemy_param[k];
if (enemyParam == null)
{
continue;
}
if (enemyParam.isDead() == true)
{
continue;
}
// 状態異常処理
// @change Developer 2016/02/23 v330 毒[最大HP割合]対応
ailmentAddResult = enemyParam.m_StatusAilmentChara.AddStatusAilment(statusAilment_data_id, nAtk, enemyParam.m_EnemyHPMax, enemyParam.getMasterDataParamChara());
// NEXTのターンを加算(特殊処理)
// 上限数以上の場合、遅延効果が発動しないように修正 @20150512 Developer
if (statusAilmentParam.category == MasterDataDefineLabel.AilmentType.FEAR &&
ailmentAddResult == true)
{
int nTurn = (int)RandManager.GetRand((uint)statusAilmentParam.Get_ABSTATE_LATE_TURN_MIN(),
(uint)statusAilmentParam.Get_ABSTATE_LATE_TURN_MAX());
enemyParam.AddTurn(nTurn);
}
}
}
break;
}
}
}
//----------------------------------------------------------------------------
/*!
* @brief アクティブスキルの発動情報からリンクスキルの発動情報作成
*/
//----------------------------------------------------------------------------
public void ActivityLinkSkill(SkillRequestParam active_skill_request_param)
{
m_SkillRequestLink.clearRequest();
//--------------------------------
// スキル情報の選定完了
//--------------------------------
int link_skill_num = CheckLinkSkillNum(active_skill_request_param, m_SkillOwner);
if (link_skill_num <= 0)
{
return;
}
//--------------------------------
// リンクスキル発動情報設定
//--------------------------------
int nSkillPower = 0;
uint unRandMin = 0;
uint unRandMax = 0;
for (int num = 0; num < (int)GlobalDefine.PartyCharaIndex.MAX; ++num)
{
if (m_SkillOwner[num] == false)
{
continue;
}
// リンクキャラを取得
CharaOnce baseChara = BattleParam.m_PlayerParty.getPartyMember((GlobalDefine.PartyCharaIndex)num, CharaParty.CharaCondition.SKILL_ACTIVE);
MasterDataParamChara linkCharaParam = BattleParam.m_MasterDataCache.useCharaParam(baseChara.m_LinkParam.m_CharaID);
if (linkCharaParam == null)
{
continue;
}
// リンクキャラのリンクスキルを取得
MasterDataSkillActive skillActiveParam = BattleParam.m_MasterDataCache.useSkillActive(linkCharaParam.link_skill_active);
if (skillActiveParam == null)
{
continue;
}
// リンクスキルを構築
BattleSkillActivity skillActivity = new BattleSkillActivity();
if (skillActivity != null)
{
// 共通情報を設定
skillActivity.m_SkillParamOwnerNum = (GlobalDefine.PartyCharaIndex)num; // 発動者(パーティキャラ)
skillActivity.m_SkillParamFieldID = InGameDefine.SELECT_NONE; // フィールドID(ブーストパネルの影響は受けない)
skillActivity.m_SkillParamSkillID = skillActiveParam.fix_id; // ノーマルスキルID
skillActivity.m_SkillType = ESKILLTYPE.eLINK; // 発動スキルの種類
skillActivity.m_Element = skillActiveParam.skill_element; // 基本情報：属性
skillActivity.m_Type = skillActiveParam.skill_type; // 基本情報：スキルタイプ
skillActivity.m_Effect = skillActiveParam.effect; // 基本情報：エフェクト
skillActivity.m_skill_chk_atk_combo = MasterDataDefineLabel.BoolType.ENABLE; // 攻撃情報：攻撃側：コンボレートの影響
// @change Developer v320 リンクスキル振れ幅対応
if (skillActiveParam.Is_skill_active())
{
// 振れ幅が設定してある場合
if (skillActiveParam.skill_value_rand != 0)
{
nSkillPower = skillActiveParam.skill_value + skillActiveParam.skill_value_rand;
if (nSkillPower < 0)
{
nSkillPower = 0;
}
// 最小値と最大値を確定：基準値より高い場合
if (nSkillPower > skillActiveParam.skill_value)
{
unRandMin = (uint)skillActiveParam.skill_value;
unRandMax = (uint)nSkillPower;
}
else
{
unRandMin = (uint)nSkillPower;
unRandMax = (uint)skillActiveParam.skill_value;
}
// スキル威力確定：振れ幅算出
skillActivity.m_skill_power = (int)RandManager.GetRand(unRandMin, unRandMax + 1);
// 効果値によるエフェクトの切り替え
skillActivity.m_Effect = InGameUtilBattle.SetSkillEffectToValue(skillActivity.m_Effect, skillActivity.m_Type, skillActivity.m_skill_power);
}
else
{
skillActivity.m_skill_power = skillActiveParam.skill_value;
}
}
// クリティカル判定
if (BattleSceneUtil.checkChancePercent(skillActiveParam.skill_critical_odds))
{
skillActivity.m_bCritical = true;
}
else
{
skillActivity.m_bCritical = false;
}
m_SkillRequestLink.addSkillRequest(skillActivity);
}
}
}
//----------------------------------------------------------------------------
/*!
* @brief リンクスキルの最大発動数をチェック
* @param[in] BattleSkillActivity[] (activityArray) ノーマルスキル発動情報
*/
//----------------------------------------------------------------------------
private static int CheckLinkSkillNum(SkillRequestParam skill_requeset_param, bool[] dest_skill_owner)
{
int ret_val = 0;
for (int idx = 0; idx < dest_skill_owner.Length; idx++)
{
dest_skill_owner[idx] = false;
}
//--------------------------------
// ノーマルスキル発動者を取得
//--------------------------------
for (int num = 0; num < skill_requeset_param.getRequestCount(); ++num)
{
BattleSkillActivity normalActivity = skill_requeset_param.getSkillRequestByIndex(num);
if (normalActivity == null ||
normalActivity.m_SkillType != ESKILLTYPE.eACTIVE ||
normalActivity.m_SkillParamOwnerNum == GlobalDefine.PartyCharaIndex.GENERAL)
{
continue;
}
// 発動者の登録処理
for (int ownerNum = 0; ownerNum < dest_skill_owner.Length; ++ownerNum)
{
if ((GlobalDefine.PartyCharaIndex)ownerNum == normalActivity.m_SkillParamOwnerNum &&
dest_skill_owner[ownerNum] == false)
{
dest_skill_owner[ownerNum] = true;
break;
}
}
}
//--------------------------------
// リンクスキル発動判定
//--------------------------------
for (int num = 0; num < dest_skill_owner.Length; ++num)
{
if (dest_skill_owner[num] == false)
{
continue;
}
// リンクキャラを取得
CharaOnce partyChara = BattleParam.m_PlayerParty.getPartyMember((GlobalDefine.PartyCharaIndex)num, CharaParty.CharaCondition.SKILL_ACTIVE);
if (partyChara == null)
{
continue;
}
MasterDataParamChara charaMaster = BattleParam.m_MasterDataCache.useCharaParam(partyChara.m_LinkParam.m_CharaID);
if (charaMaster == null)
{
dest_skill_owner[num] = false;
continue;
}
// リンクスキル発動判定(基本発動率 + リンクポイント)
uint odds = CharaLinkUtil.GetLinkSkillOdds(charaMaster, partyChara.m_LinkParam.m_CharaLinkPoint);
if (BattleSceneUtil.checkChancePercentSkill((int)odds, (int)CharaLinkUtil.SKILL_LINK_ODDS_MAX))
{
ret_val++;
}
else
{
dest_skill_owner[num] = false;
}
}
return(ret_val);
}
public void SkillCutinRequest(GlobalDefine.PartyCharaIndex charaIdx, uint skillID, ESKILLTYPE skillType)
{
BattleSkillActivity activity = getSkillActivity(charaIdx, skillID, skillType);
SetSkillCutin(activity);
}
public void SkillCutinPassive(GlobalDefine.PartyCharaIndex charaIdx, uint skillID)
{
BattleSkillActivity activity = getSkillActivity(charaIdx, skillID, ESKILLTYPE.ePASSIVE);
SetSkillCutin(activity);
}
public void SkillCutinLeader(GlobalDefine.PartyCharaIndex charaIdx, CharaParty PlayerParty)
{
BattleSkillActivity activity = getLeaderSkillActivity(charaIdx, PlayerParty);
SetSkillCutin(activity);
}