private List <DamageModelBase> _CreateRaigekiData(BakuRaiInfo Bakurai, List <ShipModel_BattleAll> ships)
{
List <DamageModelBase> list = new List <DamageModelBase>();
for (int i = 0; i < ships.get_Count(); i++)
{
ShipModel_BattleAll shipModel_BattleAll = ships.get_Item(i);
if (shipModel_BattleAll == null || Bakurai == null)
{
list.Add(null);
}
else
{
bool is_raigeki = Bakurai.IsRaigeki[i];
bool is_bakugeki = Bakurai.IsBakugeki[i];
BakuRaiDamageModel bakuRaiDamageModel = new BakuRaiDamageModel(shipModel_BattleAll, is_raigeki, is_bakugeki);
int damage = Bakurai.Damage[i];
BattleHitStatus hitstate = Bakurai.Clitical[i];
BattleDamageKinds dmgkind = Bakurai.DamageType[i];
bakuRaiDamageModel.__AddData__(damage, hitstate, dmgkind);
list.Add(bakuRaiDamageModel);
}
}
return(list);
}
public ShienModel_Hou(DeckModel shien_deck, List <ShipModel_BattleAll> ships_f, List <ShipModel_BattleAll> ships_e, SupportAtack data)
{
_shien_deck_id = shien_deck.Id;
_ships_shien = new List <ShipModel_Attacker>();
ShipModel[] ships = shien_deck.GetShips();
for (int i = 0; i < ships.Length; i++)
{
_ships_shien.Add(new __ShipModel_Attacker__(ships[i], i));
}
_ships_f = ships_f;
_ships_e = ships_e;
_data = data;
_dmg_data = new List <DamageModel>();
for (int j = 0; j < ships_e.Count; j++)
{
ShipModel_BattleAll shipModel_BattleAll = ships_e[j];
if (shipModel_BattleAll == null)
{
_dmg_data.Add(null);
continue;
}
DamageModel damageModel = new DamageModel(shipModel_BattleAll);
int damage = data.Hourai.Damage[j];
BattleHitStatus hitstate = data.Hourai.Clitical[j];
BattleDamageKinds dmgkind = data.Hourai.DamageType[j];
damageModel.__AddData__(damage, hitstate, dmgkind);
damageModel.__CalcDamage__();
_dmg_data.Add(damageModel);
}
}
public static HitState ConvertBattleHitState2HitState(DamageModelBase model)
{
HitState result = HitState.Miss;
if (model == null)
{
return(result);
}
BattleHitStatus hitState = model.GetHitState();
if (hitState != BattleHitStatus.Normal)
{
if (hitState != BattleHitStatus.Clitical)
{
result = HitState.Miss;
}
else
{
if (model.GetGurdEffect())
{
}
result = HitState.CriticalDamage;
}
}
else
{
if (model.GetGurdEffect())
{
}
result = HitState.NomalDamage;
}
return(result);
}
public void SetHp(int num, int maxHp, int nowHp, int toHp, int damage, BattleHitStatus status, bool isFriend)
{
if (!(_listHpGauge[num] == null))
{
_listHpGauge[num].SetHPGauge(maxHp, nowHp, toHp, damage, status, isFriend);
}
}
protected virtual void PlayHpGaugeDamage(UIBattleShip ship, HitState iState)
{
BattleHitStatus status = BattleHitStatus.Normal;
switch (iState)
{
case HitState.Miss:
status = BattleHitStatus.Miss;
break;
case HitState.CriticalDamage:
status = BattleHitStatus.Clitical;
break;
}
if (this._clsHougekiModel != null)
{
UICircleHPGauge circleHPGauge = BattleTaskManager.GetPrefabFile().circleHPGauge;
circleHPGauge.SetHPGauge(this._clsHougekiModel.Defender.MaxHp, this._clsHougekiModel.Defender.HpBefore, this._clsHougekiModel.Defender.HpAfter, this._clsHougekiModel.GetDamage(), status, this._clsHougekiModel.Defender.IsFriend());
Vector3 damagePosition = (!this._clsHougekiModel.Defender.IsFriend()) ? new Vector3(280f, -125f, 0f) : new Vector3(-500f, -125f, 0f);
circleHPGauge.SetDamagePosition(damagePosition);
circleHPGauge.Play(delegate
{
});
}
}
protected virtual int setDamageValue(BattleHitStatus hitType, int atkPow, int defPow, Mem_ship attacker, Mem_ship target)
{
if (hitType == BattleHitStatus.Miss)
{
return(0);
}
if (hitType == BattleHitStatus.Critical)
{
atkPow = (int)((double)atkPow * 1.5);
}
double def = (double)r.Next(defPow);
double num = (double)atkPow - ((double)defPow * 0.7 + def * 0.6);
double num2 = 100.0;
if (num2 < 50.0)
{
num = Math.Floor(num * num2 / 50.0);
}
int num4 = (int)num;
if (num4 < 1)
{
int num5 = r.Next(target.Nowhp);
num4 = (int)((double)target.Nowhp * 0.06 + (double)num5 * 0.08);
}
return(num4);
}
protected virtual int setDamageValue(BattleHitStatus hitType, int atkPow, int defPow, Mem_ship attacker, Mem_ship target, List <bool> lostFlag)
{
switch (hitType)
{
case BattleHitStatus.Miss:
return(0);
case BattleHitStatus.Clitical:
atkPow = (int)((double)atkPow * 1.5);
break;
}
double num = (double)atkPow - ((double)defPow * 0.7 + (double)randInstance.Next(defPow) * 0.6);
double num2 = 100.0;
double num3 = Mst_DataManager.Instance.Mst_ship[attacker.Ship_id].Bull_max;
if (num3 != 0.0)
{
num2 = (double)attacker.Bull / num3 * 100.0;
}
if (num2 < 50.0)
{
num = Math.Floor(num * num2 / 50.0);
}
int num4 = (int)num;
BattleShipSubInfo battleShipSubInfo;
int deckIdx;
if (attacker.IsEnemy())
{
battleShipSubInfo = E_SubInfo[attacker.Rid];
int deckIdx2 = battleShipSubInfo.DeckIdx;
deckIdx = F_SubInfo[target.Rid].DeckIdx;
}
else
{
battleShipSubInfo = F_SubInfo[attacker.Rid];
int deckIdx3 = battleShipSubInfo.DeckIdx;
deckIdx = E_SubInfo[target.Rid].DeckIdx;
}
if (num4 < 1)
{
int num5 = randInstance.Next(target.Nowhp);
num4 = (int)((double)target.Nowhp * 0.06 + (double)num5 * 0.08);
}
if (num4 >= target.Nowhp && !target.IsEnemy() && deckIdx == 0)
{
num4 = (int)((double)target.Nowhp * 0.5 + (double)randInstance.Next(target.Nowhp) * 0.3);
}
if (lostFlag != null && num4 >= target.Nowhp && !lostFlag[deckIdx])
{
num4 = target.Nowhp - 1;
}
double lovHoseiDamageKeisu = getLovHoseiDamageKeisu(target, num4);
num4 = (int)((double)num4 * lovHoseiDamageKeisu);
battleShipSubInfo.TotalDamage += num4;
target.SubHp(num4);
return(num4);
}
public void SetHp(int num, int maxHp, int nowHp, int toHp, int damage, BattleHitStatus status, bool isFriend)
{
if (this._listHpGauge.get_Item(num) == null)
{
return;
}
this._listHpGauge.get_Item(num).SetHPGauge(maxHp, nowHp, toHp, damage, status, isFriend);
}
protected int _AddData(int damage, BattleHitStatus hitstate, BattleDamageKinds dmgkind)
{
this._calc_damages.Add(damage);
this._damages.Add(damage);
this._hitstates.Add(hitstate);
this._dmgkind.Add(dmgkind);
return(this._damages.get_Count());
}
protected int _AddData(int damage, BattleHitStatus hitstate, BattleDamageKinds dmgkind)
{
_calc_damages.Add(damage);
_damages.Add(damage);
_hitstates.Add(hitstate);
_dmgkind.Add(dmgkind);
return(_damages.Count);
}
private void _setHpGauge(FleetType type)
{
int num = (type != 0) ? _fBattleship.Count : _eBattleship.Count;
bool flag = (type == FleetType.Friend) ? true : false;
FleetType key = flag ? FleetType.Enemy : FleetType.Friend;
List <ShipModel_Defender> defenders = _clsKoukuu.GetDefenders((!flag) ? true : false, all: true);
for (int i = 0; i < _dicBakuraiModel[type].Length; i++)
{
if (_dicBakuraiModel[type][i] == null)
{
continue;
}
ShipModel_Defender defender = _dicBakuraiModel[type][i].Defender;
switch (_dicBakuraiModel[type][i].GetHitState())
{
case BattleHitStatus.Normal:
if (_dicHitState[key][defender.Index] != HpHitState.Critical)
{
_dicHitState[key][defender.Index] = HpHitState.Hit;
}
break;
case BattleHitStatus.Clitical:
_dicHitState[key][defender.Index] = HpHitState.Critical;
break;
case BattleHitStatus.Miss:
if (_dicHitState[key][defender.Index] == HpHitState.None)
{
_dicHitState[key][defender.Index] = HpHitState.Miss;
}
break;
}
}
for (int j = 0; j < num; j++)
{
int damage = _clsKoukuu.GetAttackDamage(defenders[j].TmpId)?.GetDamage() ?? (-1);
BattleHitStatus status = (_dicHitState[key][j] != HpHitState.Miss) ? ((_dicHitState[key][j] != HpHitState.Critical) ? BattleHitStatus.Normal : BattleHitStatus.Clitical) : BattleHitStatus.Miss;
_battleHpGauges.Init();
_battleHpGauges.SetGauge(j, flag, isLight: true, isT: false, isNumber: false);
if (flag)
{
_battleHpGauges.SetHp(j, defenders[j].MaxHp, defenders[j].HpBefore, defenders[j].HpAfter, damage, status, isFriend: false);
}
else
{
_battleHpGauges.SetHp(j, defenders[j].MaxHp, defenders[j].HpBefore, defenders[j].HpAfter, damage, status, isFriend: false);
}
}
}
protected virtual void battleBakurai(BattleBaseData attacker, BattleBaseData target, Dictionary <Mem_ship, List <FighterInfo> > fighter, ref BakuRaiInfo bakurai)
{
Mst_slotitem slotitem = (!attacker.ShipData[0].IsEnemy()) ? fTouchPlane : eTouchPlane;
List <Mem_ship> list = target.ShipData.ToList();
list.RemoveAll((Mem_ship x) => (x.Nowhp <= 0) ? true : false);
foreach (KeyValuePair <Mem_ship, List <FighterInfo> > item in fighter)
{
Mem_ship key = item.Key;
foreach (FighterInfo item2 in item.Value)
{
if (key.Onslot[item2.SlotIdx] > 0 && item2.ValidBakurai())
{
BattleDamageKinds dKind = BattleDamageKinds.Normal;
Mem_ship atackTarget = getAtackTarget(key, list, overKill: true, subMarineFlag: false, rescueFlag: true, ref dKind);
if (atackTarget != null)
{
int num = target.ShipData.IndexOf(atackTarget);
int bakuraiAtkPow = getBakuraiAtkPow(item2, key.Onslot[item2.SlotIdx], atackTarget);
bakuraiAtkPow = (int)((double)bakuraiAtkPow * getTouchPlaneKeisu(slotitem));
int soukou = atackTarget.Soukou;
int hitPorb = getHitPorb();
int battleAvo = getBattleAvo(FormationDatas.GetFormationKinds.AIR, atackTarget);
BattleHitStatus hitStatus = getHitStatus(hitPorb, battleAvo, key, atackTarget, 0.2, airAttack: true);
int num2 = setDamageValue(hitStatus, bakuraiAtkPow, soukou, key, atackTarget, target.LostFlag);
bakurai.Damage[num] += num2;
BattleDamageKinds battleDamageKinds = dKind;
if (battleDamageKinds == BattleDamageKinds.Rescue && bakurai.DamageType[num] != BattleDamageKinds.Rescue)
{
bakurai.DamageType[num] = BattleDamageKinds.Rescue;
}
if (bakurai.Clitical[num] != BattleHitStatus.Clitical && hitStatus == BattleHitStatus.Clitical)
{
bakurai.Clitical[num] = hitStatus;
}
if (item2.Kind == FighterInfo.FighterKinds.BAKU)
{
bakurai.IsBakugeki[num] = true;
}
else if (item2.Kind == FighterInfo.FighterKinds.RAIG)
{
bakurai.IsRaigeki[num] = true;
}
}
}
}
}
}
private Support_HouRai getRaigekiData()
{
BattleBaseData f_Data = F_Data;
BattleBaseData e_Data = E_Data;
List <Mem_ship> list = E_Data.ShipData.ToList();
list.RemoveAll(delegate(Mem_ship x)
{
if (x.Nowhp <= 0)
{
return(true);
}
return(Mst_DataManager.Instance.Mst_stype[x.Stype].IsLandFacillity(Mst_DataManager.Instance.Mst_ship[x.Ship_id].Soku) ? true : false);
});
if (list.Count() == 0)
{
return(null);
}
Support_HouRai support_HouRai = new Support_HouRai();
foreach (int f_AtkIdx in f_AtkIdxs)
{
Mem_ship mem_ship = f_Data.ShipData[f_AtkIdx];
List <Mst_slotitem> atk_slot = f_Data.SlotData[f_AtkIdx];
BattleDamageKinds dKind = BattleDamageKinds.Normal;
Mem_ship atackTarget = getAtackTarget(mem_ship, list, overKill: true, subMarineFlag: false, rescueFlag: true, ref dKind);
if (atackTarget != null)
{
int num = e_Data.ShipData.IndexOf(atackTarget);
int raigAttackValue = getRaigAttackValue(mem_ship, atk_slot, atackTarget);
int soukou = atackTarget.Soukou;
int raigHitProb = getRaigHitProb(mem_ship, atk_slot, raigAttackValue);
int battleAvo = getBattleAvo(FormationDatas.GetFormationKinds.RAIGEKI, atackTarget);
BattleHitStatus hitStatus = getHitStatus(raigHitProb, battleAvo, mem_ship, atackTarget, valance3, airAttack: false);
int num2 = setDamageValue(hitStatus, raigAttackValue, soukou, mem_ship, atackTarget, null);
support_HouRai.Damage[num] += num2;
if (hitStatus != 0 && support_HouRai.Clitical[num] != BattleHitStatus.Clitical)
{
support_HouRai.Clitical[num] = hitStatus;
}
if (support_HouRai.DamageType[num] != BattleDamageKinds.Rescue)
{
support_HouRai.DamageType[num] = dKind;
}
}
}
return(support_HouRai);
}
private Support_HouRai getRaigekiData()
{
BattleBaseData f_Data = this.F_Data;
BattleBaseData e_Data = this.E_Data;
List <Mem_ship> list = Enumerable.ToList <Mem_ship>(this.E_Data.ShipData);
list.RemoveAll((Mem_ship x) => x.Nowhp <= 0 || Mst_DataManager.Instance.Mst_stype.get_Item(x.Stype).IsLandFacillity(Mst_DataManager.Instance.Mst_ship.get_Item(x.Ship_id).Soku));
if (Enumerable.Count <Mem_ship>(list) == 0)
{
return(null);
}
Support_HouRai support_HouRai = new Support_HouRai();
using (List <int> .Enumerator enumerator = this.f_AtkIdxs.GetEnumerator())
{
while (enumerator.MoveNext())
{
int current = enumerator.get_Current();
Mem_ship mem_ship = f_Data.ShipData.get_Item(current);
List <Mst_slotitem> atk_slot = f_Data.SlotData.get_Item(current);
BattleDamageKinds battleDamageKinds = BattleDamageKinds.Normal;
Mem_ship atackTarget = base.getAtackTarget(mem_ship, list, true, false, true, ref battleDamageKinds);
if (atackTarget != null)
{
int num = e_Data.ShipData.IndexOf(atackTarget);
int raigAttackValue = this.getRaigAttackValue(mem_ship, atk_slot, atackTarget);
int soukou = atackTarget.Soukou;
int raigHitProb = this.getRaigHitProb(mem_ship, atk_slot, raigAttackValue);
int battleAvo = base.getBattleAvo(FormationDatas.GetFormationKinds.RAIGEKI, atackTarget);
BattleHitStatus hitStatus = this.getHitStatus(raigHitProb, battleAvo, mem_ship, atackTarget, this.valance3, false);
int num2 = this.setDamageValue(hitStatus, raigAttackValue, soukou, mem_ship, atackTarget, null);
support_HouRai.Damage[num] += num2;
if (hitStatus != BattleHitStatus.Miss && support_HouRai.Clitical[num] != BattleHitStatus.Clitical)
{
support_HouRai.Clitical[num] = hitStatus;
}
if (support_HouRai.DamageType[num] != BattleDamageKinds.Rescue)
{
support_HouRai.DamageType[num] = battleDamageKinds;
}
}
}
}
return(support_HouRai);
}
public HougekiData getAttackData(Mem_ship attacker, List <Mst_slotitem> attackerSlot, List <int> attackerSlotLevel, Mem_ship atackTarget)
{
HougekiData hougeki = new HougekiData();
int num2;
int num3;
num2 = this.getHougAttackValue(attacker, attackerSlot, attackerSlotLevel, atackTarget);
num3 = this.getHougHitProb(attacker, attackerSlot, attackerSlotLevel);
calHitProb = num3;
int battleAvo = getBattleAvo(atackTarget);
calAvoProb = battleAvo;
BattleHitStatus battleHitStatus = this.getHitStatus(num3, battleAvo, attacker, atackTarget, this.valance3);
int num4 = this.setDamageValue(battleHitStatus, num2, atackTarget.Soukou, attacker, atackTarget);
hougeki.Damage = (num4);
hougeki.Critical = (battleHitStatus);
return(hougeki);
}
public void SetHPGauge(int maxHP, int beforeHP, int afterHP, int damage, BattleHitStatus status, bool isFriend)
{
_uiHPLabel.textInt = beforeHP;
_nMaxHP = maxHP;
_nFromHP = beforeHP;
_nToHP = ((afterHP > 0) ? afterHP : 0);
_nDamage = ((damage < 100000) ? damage : 99999);
_hitType = ((_nDamage <= 0) ? status : status);
base.transform.localPosition = ((!isFriend) ? (Vector3.left * 200f) : (Vector3.right * 200f));
if (_hitType == BattleHitStatus.Miss)
{
_nDamage = -1;
}
int now = (int)Math.Floor((float)_nFromHP);
_uiHPLabel.textInt = _nFromHP;
_uiForeground.color = Util.HpGaugeColor2(_nMaxHP, now);
_uiHPLabel.color = Util.HpLabelColor(_nMaxHP, now);
_uiForeground.fillAmount = Mathe.Rate(0f, _nMaxHP, _nFromHP);
setDamageLabelPos();
}
public BattleHitStatus GetHitState()
{
if (this._hitstates.get_Count() == 0)
{
return(BattleHitStatus.Miss);
}
BattleHitStatus battleHitStatus = this._hitstates.get_Item(0);
for (int i = 1; i < this._hitstates.get_Count(); i++)
{
if (this._hitstates.get_Item(i) == BattleHitStatus.Clitical)
{
return(BattleHitStatus.Clitical);
}
if (this._hitstates.get_Item(i) == BattleHitStatus.Normal && battleHitStatus == BattleHitStatus.Miss)
{
battleHitStatus = BattleHitStatus.Normal;
}
}
return(battleHitStatus);
}
public void SetHPGauge(int maxHP, int beforeHP, int afterHP, int damage, BattleHitStatus status, bool isFriend)
{
this._uiHPLabel.textInt = beforeHP;
this._nMaxHP = maxHP;
this._nFromHP = beforeHP;
this._nToHP = ((afterHP <= 0) ? 0 : afterHP);
this._nDamage = ((damage < 100000) ? damage : 99999);
this._hitType = ((this._nDamage <= 0) ? status : status);
base.get_transform().set_localPosition((!isFriend) ? (Vector3.get_left() * 200f) : (Vector3.get_right() * 200f));
if (this._hitType == BattleHitStatus.Miss)
{
this._nDamage = -1;
}
int now = (int)Math.Floor((double)((float)this._nFromHP));
this._uiHPLabel.textInt = this._nFromHP;
this._uiForeground.color = Util.HpGaugeColor2(this._nMaxHP, now);
this._uiHPLabel.color = Util.HpLabelColor(this._nMaxHP, now);
this._uiForeground.fillAmount = Mathe.Rate(0f, (float)this._nMaxHP, (float)this._nFromHP);
this.setDamageLabelPos();
}
public BattleHitStatus GetHitState()
{
if (_hitstates.Count == 0)
{
return(BattleHitStatus.Miss);
}
BattleHitStatus battleHitStatus = _hitstates[0];
for (int i = 1; i < _hitstates.Count; i++)
{
if (_hitstates[i] == BattleHitStatus.Clitical)
{
return(BattleHitStatus.Clitical);
}
if (_hitstates[i] == BattleHitStatus.Normal && battleHitStatus == BattleHitStatus.Miss)
{
battleHitStatus = BattleHitStatus.Normal;
}
}
return(battleHitStatus);
}
private void _setHpGauge()
{
BattleCutInCamera cutInCamera = BattleTaskManager.GetBattleCameras().cutInCamera;
bool flag = false;
_eHpPos = _setHpGaugePosition(_eBattleship.Count);
_eHitState = new HpHitState[_eBattleship.Count];
UIPanel uIPanel = Resources.Load <UIPanel>("Prefabs/Battle/UI/UICircleHpPanel");
_uiHpGaugePanel = Util.Instantiate(uIPanel.gameObject, cutInCamera.transform.gameObject).GetComponent <UIPanel>();
for (int i = 0; i < _defenders.Count; i++)
{
DamageModel attackDamage = _clsShelling.GetAttackDamage(_defenders[i].TmpId);
if (attackDamage.GetHitState() == BattleHitStatus.Clitical)
{
_eHitState[attackDamage.Defender.Index] = HpHitState.Critical;
}
else if (attackDamage.GetHitState() == BattleHitStatus.Miss)
{
if (_eHitState[attackDamage.Defender.Index] == HpHitState.None)
{
_eHitState[attackDamage.Defender.Index] = HpHitState.Miss;
}
}
else if (attackDamage.GetHitState() == BattleHitStatus.Normal && _eHitState[attackDamage.Defender.Index] != HpHitState.Critical)
{
_eHitState[attackDamage.Defender.Index] = HpHitState.Hit;
}
BattleHitStatus status = (_eHitState[i] != HpHitState.Miss) ? ((_eHitState[i] != HpHitState.Critical) ? BattleHitStatus.Normal : BattleHitStatus.Clitical) : BattleHitStatus.Miss;
_battleHpGauges.SetGauge(i, isFriend: false, isLight: true, isT: false, isNumber: false);
_battleHpGauges.SetHp(i, _defenders[i].MaxHp, _defenders[i].HpBefore, _defenders[i].HpAfter, attackDamage.GetDamage(), status, isFriend: false);
if (attackDamage.GetProtectEffect() && !flag)
{
flag = true;
_isProtect = true;
_rescueCutIn.AddShipList(_eBattleship[0], _eBattleship[i]);
}
}
}
private void _setHpGauge()
{
bool flag = false;
_eHitState = new HpHitState[_eBattleship.Count];
List<ShipModel_Defender> defenders = _clsTorpedo.GetDefenders(is_friend: false);
for (int i = 0; i < defenders.Count; i++)
{
DamageModel attackDamage = _clsTorpedo.GetAttackDamage(defenders[i].TmpId);
switch (attackDamage.GetHitState())
{
case BattleHitStatus.Normal:
if (_eHitState[i] != HpHitState.Critical)
{
_eHitState[i] = HpHitState.Hit;
}
break;
case BattleHitStatus.Clitical:
_eHitState[i] = HpHitState.Critical;
break;
case BattleHitStatus.Miss:
if (_eHitState[i] == HpHitState.None)
{
_eHitState[i] = HpHitState.Miss;
}
break;
}
BattleHitStatus status = (_eHitState[i] != HpHitState.Miss) ? ((_eHitState[i] != HpHitState.Critical) ? BattleHitStatus.Normal : BattleHitStatus.Clitical) : BattleHitStatus.Miss;
_battleHpGauges.SetGauge(i, isFriend: false, isLight: false, isT: true, isNumber: false);
_battleHpGauges.SetHp(i, defenders[i].MaxHp, defenders[i].HpBefore, defenders[i].HpAfter, attackDamage.GetDamage(), status, isFriend: false);
if (attackDamage.GetProtectEffect() && !flag)
{
flag = true;
_isProtect = true;
_rescueCutIn.AddShipList(_eBattleship[0], _eBattleship[i]);
}
}
}
private void _setHpGauge()
{
_eHpPos = new Vector3[_eBattleship.Count];
_eHpPos = _setHpPosition(FleetType.Enemy, _eBattleship.Count);
List <ShipModel_Defender> defenders = _clsAerial.GetDefenders(is_friend: false, all: true);
for (int i = 0; i < _fBakuraiModel.Length; i++)
{
if (_fBakuraiModel[i] == null)
{
continue;
}
ShipModel_Defender defender = _fBakuraiModel[i].Defender;
if (_fBakuraiModel[i].GetHitState() == BattleHitStatus.Clitical)
{
_eHitState[defender.Index] = HpHitState.Critical;
}
else if (_fBakuraiModel[i].GetHitState() == BattleHitStatus.Miss)
{
if (_eHitState[defender.Index] == HpHitState.None)
{
_eHitState[defender.Index] = HpHitState.Miss;
}
}
else if (_fBakuraiModel[i].GetHitState() == BattleHitStatus.Normal && _eHitState[defender.Index] != HpHitState.Critical)
{
_eHitState[defender.Index] = HpHitState.Hit;
}
}
for (int j = 0; j < _eBattleship.Count; j++)
{
BattleHitStatus status = (_eHitState[j] != HpHitState.Miss) ? ((_eHitState[j] != HpHitState.Critical) ? BattleHitStatus.Normal : BattleHitStatus.Clitical) : BattleHitStatus.Miss;
_battleHpGauges.SetGauge(j, isFriend: false, isLight: true, isT: false, isNumber: false);
_battleHpGauges.SetHp(j, defenders[j].MaxHp, defenders[j].HpBefore, defenders[j].HpAfter, _clsAerial.GetAttackDamage(defenders[j].TmpId).GetDamage(), status, isFriend: false);
}
}
public void __AddData__(int damage, BattleHitStatus hitstate, BattleDamageKinds dmgkind)
{
base._AddData(damage, hitstate, dmgkind);
}
private Support_HouRai getHougekiData()
{
BattleBaseData f_Data = this.F_Data;
BattleBaseData e_Data = this.E_Data;
List <Mem_ship> list = Enumerable.ToList <Mem_ship>(e_Data.ShipData);
list.RemoveAll((Mem_ship x) => x.Nowhp <= 0 || Mst_DataManager.Instance.Mst_stype.get_Item(x.Stype).IsSubmarine());
if (Enumerable.Count <Mem_ship>(list) == 0)
{
return(null);
}
Support_HouRai support_HouRai = new Support_HouRai();
int i = 0;
while (i < this.F_Data.ShipData.get_Count())
{
Mem_ship mem_ship = f_Data.ShipData.get_Item(i);
List <Mst_slotitem> list2 = f_Data.SlotData.get_Item(i);
BattleAtackKinds_Day kind = BattleAtackKinds_Day.Normal;
if (base.IsAirAttackGroup(mem_ship, list2, BattleCommand.None))
{
if (base.CanAirAtack_DamageState(mem_ship))
{
if (base.CanAirAttack(mem_ship, list2))
{
kind = BattleAtackKinds_Day.AirAttack;
goto IL_CA;
}
}
}
else if (base.isValidHougeki(mem_ship))
{
goto IL_CA;
}
IL_1B3:
i++;
continue;
IL_CA:
BattleDamageKinds battleDamageKinds = BattleDamageKinds.Normal;
Mem_ship atackTarget = base.getAtackTarget(mem_ship, list, true, false, true, ref battleDamageKinds);
if (atackTarget == null)
{
goto IL_1B3;
}
int deckIdx = this.E_SubInfo.get_Item(atackTarget.Rid).DeckIdx;
int hougAttackValue = this.getHougAttackValue(kind, mem_ship, list2, atackTarget, 0);
int soukou = atackTarget.Soukou;
int hougHitProb = this.getHougHitProb(kind, mem_ship, list2, 0);
int battleAvo = base.getBattleAvo(FormationDatas.GetFormationKinds.HOUGEKI, atackTarget);
BattleHitStatus hitStatus = this.getHitStatus(hougHitProb, battleAvo, mem_ship, atackTarget, this.valance3, false);
int num = this.setDamageValue(hitStatus, hougAttackValue, soukou, mem_ship, atackTarget, e_Data.LostFlag);
support_HouRai.Damage[deckIdx] += num;
if (hitStatus != BattleHitStatus.Miss && support_HouRai.Clitical[deckIdx] != BattleHitStatus.Clitical)
{
support_HouRai.Clitical[deckIdx] = hitStatus;
}
if (support_HouRai.DamageType[deckIdx] != BattleDamageKinds.Rescue)
{
support_HouRai.DamageType[deckIdx] = battleDamageKinds;
goto IL_1B3;
}
goto IL_1B3;
}
return(support_HouRai);
}
private Hougeki <BattleAtackKinds_Day> getAttackData(Mem_ship attacker, List <Mst_slotitem> attackerSlot, List <int> attackerSlotLevel, BattleAtackKinds_Day attackType, bool submarine_flag, KeyValuePair <int, int> submarine_keisu, List <Mem_ship> targetShips, List <bool> targetLostFlags, Dictionary <int, BattleShipSubInfo> targetSubInfo, int powerDownType)
{
BattleDamageKinds dKind = BattleDamageKinds.Normal;
Mem_ship atackTarget = getAtackTarget(attacker, targetShips, overKill: false, submarine_flag, rescueFlag: true, ref dKind);
if (atackTarget == null)
{
return(null);
}
int deckIdx = targetSubInfo[atackTarget.Rid].DeckIdx;
Hougeki <BattleAtackKinds_Day> hougeki = new Hougeki <BattleAtackKinds_Day>();
hougeki.Attacker = attacker.Rid;
hougeki.SpType = attackType;
int num = (attackType != BattleAtackKinds_Day.Renzoku) ? 1 : 2;
for (int i = 0; i < num; i++)
{
int soukou = atackTarget.Soukou;
hougeki.Target.Add(atackTarget.Rid);
int num2;
int num3;
FormationDatas.GetFormationKinds battleState;
if (submarine_flag)
{
num2 = getSubmarineAttackValue(submarine_keisu, attacker, attackerSlot, attackerSlotLevel);
num3 = getSubmarineHitProb(attacker, attackerSlot, attackerSlotLevel);
battleState = FormationDatas.GetFormationKinds.SUBMARINE;
}
else
{
int tekkouKind = getTekkouKind(atackTarget.Stype, attackerSlot);
num2 = getHougAttackValue(attackType, attacker, attackerSlot, atackTarget, tekkouKind);
num3 = getHougHitProb(attackType, attacker, attackerSlot, tekkouKind);
battleState = FormationDatas.GetFormationKinds.HOUGEKI;
}
int battleAvo = getBattleAvo(battleState, atackTarget);
switch (powerDownType)
{
case 1:
num2 = (int)((double)num2 * 0.55);
num3 = (int)((double)num3 * 0.55);
break;
case 2:
num3 = (int)((double)num3 * 0.55);
break;
}
bool airAttack = (attackType == BattleAtackKinds_Day.AirAttack) ? true : false;
BattleHitStatus battleHitStatus = getHitStatus(num3, battleAvo, attacker, atackTarget, valance3, airAttack);
if (battleHitStatus == BattleHitStatus.Miss && enableSpType.Contains(attackType))
{
battleHitStatus = BattleHitStatus.Normal;
}
int item = setDamageValue(battleHitStatus, num2, soukou, attacker, atackTarget, targetLostFlags);
hougeki.Damage.Add(item);
hougeki.Clitical.Add(battleHitStatus);
hougeki.DamageKind.Add(dKind);
}
if (attacker.IsEnemy())
{
RecoveryShip(deckIdx);
}
return(hougeki);
}
public int __AddData__(int damage, BattleHitStatus hitstate, BattleDamageKinds dmgkind)
{
_attackers.Add(null);
return(_AddData(damage, hitstate, dmgkind));
}
private Hougeki <BattleAtackKinds_Night> getHougekiData(int atk_idx, Mem_ship attacker)
{
if (attacker.Get_DamageState() == DamageState.Taiha || !attacker.IsFight())
{
return(null);
}
Func <int, bool> func = null;
BattleBaseData battleBaseData;
Dictionary <int, BattleShipSubInfo> dictionary;
BattleBaseData battleBaseData2;
Dictionary <int, BattleShipSubInfo> dictionary2;
List <int> list;
double cliticalKeisu;
if (attacker.IsEnemy())
{
battleBaseData = this.E_Data;
dictionary = this.E_SubInfo;
battleBaseData2 = this.F_Data;
dictionary2 = this.F_SubInfo;
func = new Func <int, bool>(base.RecoveryShip);
list = this.fSerchLightIdxs;
double num = this.eValance1;
double num2 = this.eValance2;
cliticalKeisu = this.eValance3;
}
else
{
battleBaseData = this.F_Data;
dictionary = this.F_SubInfo;
battleBaseData2 = this.E_Data;
dictionary2 = this.E_SubInfo;
list = this.eSerchLightIdxs;
double num = this.fValance1;
double num2 = this.fValance2;
cliticalKeisu = this.fValance3;
}
if (!this.isAttackerFromTargetKind(dictionary.get_Item(attacker.Rid)))
{
return(null);
}
Hougeki <BattleAtackKinds_Night> hougeki = new Hougeki <BattleAtackKinds_Night>();
KeyValuePair <int, int> subMarineAtackKeisu = this.getSubMarineAtackKeisu(battleBaseData2.ShipData, attacker, battleBaseData.SlotData.get_Item(atk_idx), true);
bool flag = false;
if (subMarineAtackKeisu.get_Key() != 0)
{
hougeki.SpType = ((subMarineAtackKeisu.get_Key() != 1) ? BattleAtackKinds_Night.AirAttack : BattleAtackKinds_Night.Bakurai);
hougeki.Slot_List.Add(0);
flag = true;
}
BattleDamageKinds battleDamageKinds = BattleDamageKinds.Normal;
Mem_ship atackTarget = base.getAtackTarget(attacker, battleBaseData2.ShipData, false, flag, true, ref battleDamageKinds);
if (atackTarget == null)
{
return(null);
}
int deckIdx = dictionary2.get_Item(atackTarget.Rid).DeckIdx;
if (atackTarget.Nowhp > 1 && list.get_Count() > 0 && list.get_Item(0) == deckIdx)
{
battleDamageKinds = BattleDamageKinds.Normal;
atackTarget = base.getAtackTarget(attacker, battleBaseData2.ShipData, false, flag, true, ref battleDamageKinds);
deckIdx = dictionary2.get_Item(atackTarget.Rid).DeckIdx;
}
if (!flag)
{
this.setSlotData(atk_idx, attacker, battleBaseData.SlotData.get_Item(atk_idx), atackTarget, hougeki);
}
hougeki.Attacker = attacker.Rid;
int num3 = (hougeki.SpType != BattleAtackKinds_Night.Renzoku) ? 1 : 2;
HashSet <BattleAtackKinds_Night> hashSet = new HashSet <BattleAtackKinds_Night>();
hashSet.Add(BattleAtackKinds_Night.Rai_Rai);
hashSet.Add(BattleAtackKinds_Night.Renzoku);
hashSet.Add(BattleAtackKinds_Night.Syu_Rai);
hashSet.Add(BattleAtackKinds_Night.Syu_Syu_Fuku);
hashSet.Add(BattleAtackKinds_Night.Syu_Syu_Syu);
HashSet <BattleAtackKinds_Night> hashSet2 = hashSet;
for (int i = 0; i < num3; i++)
{
int soukou = atackTarget.Soukou;
List <Mst_slotitem> list2 = battleBaseData.SlotData.get_Item(atk_idx);
int atkPow;
int hitProb;
FormationDatas.GetFormationKinds battleState;
if (flag)
{
atkPow = this.getSubmarineAttackValue(subMarineAtackKeisu, attacker, list2, battleBaseData.SlotLevel.get_Item(atk_idx));
hitProb = base.getSubmarineHitProb(attacker, battleBaseData.SlotData.get_Item(atk_idx), battleBaseData.SlotLevel.get_Item(atk_idx));
battleState = FormationDatas.GetFormationKinds.SUBMARINE;
}
else
{
atkPow = this.getMidnightAttackValue(hougeki.SpType, attacker, list2, atackTarget);
hitProb = this.getMidnightHitProb(hougeki.SpType, attacker, list2, list);
battleState = FormationDatas.GetFormationKinds.MIDNIGHT;
}
int battleAvo_Midnight = base.getBattleAvo_Midnight(battleState, atackTarget, list.Contains(deckIdx));
BattleHitStatus battleHitStatus = this.getHitStatus(hitProb, battleAvo_Midnight, attacker, atackTarget, cliticalKeisu, false);
if (battleHitStatus == BattleHitStatus.Miss && hashSet2.Contains(hougeki.SpType))
{
battleHitStatus = BattleHitStatus.Normal;
}
hougeki.Target.Add(atackTarget.Rid);
int num4 = this.setDamageValue(battleHitStatus, atkPow, soukou, attacker, atackTarget, battleBaseData2.LostFlag);
hougeki.Damage.Add(num4);
hougeki.Clitical.Add(battleHitStatus);
hougeki.DamageKind.Add(battleDamageKinds);
}
if (func != null)
{
bool flag2 = func.Invoke(deckIdx);
}
return(hougeki);
}
protected virtual RaigekiInfo getRaigekiData(bool enemyFlag)
{
RaigekiInfo raigekiInfo = new RaigekiInfo();
List <int> list;
BattleBaseData battleBaseData;
Dictionary <int, BattleShipSubInfo> dictionary;
BattleBaseData battleBaseData2;
Dictionary <int, BattleShipSubInfo> dictionary2;
if (enemyFlag)
{
list = e_AtkIdxs;
battleBaseData = E_Data;
dictionary = E_SubInfo;
battleBaseData2 = F_Data;
dictionary2 = F_SubInfo;
}
else
{
list = f_AtkIdxs;
battleBaseData = F_Data;
dictionary = F_SubInfo;
battleBaseData2 = E_Data;
dictionary2 = E_SubInfo;
}
int num = list.Count();
if (num == 0)
{
return(raigekiInfo);
}
List <Mem_ship> list2 = battleBaseData2.ShipData.ToList();
Dictionary <int, Mst_stype> mst_stype = Mst_DataManager.Instance.Mst_stype;
Dictionary <int, Mst_ship> mst_ship = Mst_DataManager.Instance.Mst_ship;
list2.RemoveAll(delegate(Mem_ship x)
{
if (x.Nowhp <= 0)
{
return(true);
}
return(mst_stype[x.Stype].IsLandFacillity(mst_ship[x.Ship_id].Soku) ? true : false);
});
if (list2.Count == 0)
{
return(raigekiInfo);
}
for (int i = 0; i < num; i++)
{
int num2 = list[i];
Mem_ship mem_ship = battleBaseData.ShipData[num2];
List <Mst_slotitem> atk_slot = battleBaseData.SlotData[num2];
if (isAttackerFromTargetKind(dictionary[mem_ship.Rid]))
{
BattleDamageKinds dKind = BattleDamageKinds.Normal;
Mem_ship atackTarget = getAtackTarget(mem_ship, list2, overKill: true, subMarineFlag: false, rescueFlag: true, ref dKind);
if (atackTarget != null)
{
int deckIdx = dictionary2[atackTarget.Rid].DeckIdx;
int raigAttackValue = getRaigAttackValue(mem_ship, atk_slot, atackTarget);
int soukou = atackTarget.Soukou;
int raigHitProb = getRaigHitProb(mem_ship, atk_slot, raigAttackValue);
int battleAvo = getBattleAvo(FormationDatas.GetFormationKinds.RAIGEKI, atackTarget);
BattleHitStatus hitStatus = getHitStatus(raigHitProb, battleAvo, mem_ship, atackTarget, valance3, airAttack: false);
int num3 = setDamageValue(hitStatus, raigAttackValue, soukou, mem_ship, atackTarget, battleBaseData2.LostFlag);
raigekiInfo.Damage[num2] = num3;
raigekiInfo.Target[num2] = deckIdx;
raigekiInfo.DamageKind[num2] = dKind;
raigekiInfo.Clitical[num2] = hitStatus;
}
}
}
return(raigekiInfo);
}
public int __AddData__(ShipModel_BattleAll attacker, int damage, BattleHitStatus hitstate, BattleDamageKinds dmgkind)
{
this._attackers.Add(attacker.__CreateAttacker__());
return(base._AddData(damage, hitstate, dmgkind));
}
private Support_HouRai getHougekiData()
{
BattleBaseData f_Data = F_Data;
BattleBaseData e_Data = E_Data;
List <Mem_ship> list = e_Data.ShipData.ToList();
list.RemoveAll(delegate(Mem_ship x)
{
if (x.Nowhp <= 0)
{
return(true);
}
return(Mst_DataManager.Instance.Mst_stype[x.Stype].IsSubmarine() ? true : false);
});
if (list.Count() == 0)
{
return(null);
}
Support_HouRai support_HouRai = new Support_HouRai();
for (int i = 0; i < F_Data.ShipData.Count; i++)
{
Mem_ship mem_ship = f_Data.ShipData[i];
List <Mst_slotitem> list2 = f_Data.SlotData[i];
BattleAtackKinds_Day kind = BattleAtackKinds_Day.Normal;
if (IsAirAttackGroup(mem_ship, list2, BattleCommand.None))
{
if (!CanAirAtack_DamageState(mem_ship) || !CanAirAttack(mem_ship, list2))
{
continue;
}
kind = BattleAtackKinds_Day.AirAttack;
}
else if (!isValidHougeki(mem_ship))
{
continue;
}
BattleDamageKinds dKind = BattleDamageKinds.Normal;
Mem_ship atackTarget = getAtackTarget(mem_ship, list, overKill: true, subMarineFlag: false, rescueFlag: true, ref dKind);
if (atackTarget != null)
{
int deckIdx = E_SubInfo[atackTarget.Rid].DeckIdx;
int hougAttackValue = getHougAttackValue(kind, mem_ship, list2, atackTarget, 0);
int soukou = atackTarget.Soukou;
int hougHitProb = getHougHitProb(kind, mem_ship, list2, 0);
int battleAvo = getBattleAvo(FormationDatas.GetFormationKinds.HOUGEKI, atackTarget);
BattleHitStatus hitStatus = getHitStatus(hougHitProb, battleAvo, mem_ship, atackTarget, valance3, airAttack: false);
int num = setDamageValue(hitStatus, hougAttackValue, soukou, mem_ship, atackTarget, e_Data.LostFlag);
support_HouRai.Damage[deckIdx] += num;
if (hitStatus != 0 && support_HouRai.Clitical[deckIdx] != BattleHitStatus.Clitical)
{
support_HouRai.Clitical[deckIdx] = hitStatus;
}
if (support_HouRai.DamageType[deckIdx] != BattleDamageKinds.Rescue)
{
support_HouRai.DamageType[deckIdx] = dKind;
}
}
}
return(support_HouRai);
}
