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);
}
}
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);
}
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);
}
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 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);
}
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 Mem_ship getAtackTarget(Mem_ship attacker, List <Mem_ship> targetShips, bool overKill, bool subMarineFlag, bool rescueFlag, ref BattleDamageKinds dKind)
{
Dictionary <int, Mst_stype> stypes = Mst_DataManager.Instance.Mst_stype;
IEnumerable <Mem_ship> enumerable;
if (!overKill)
{
enumerable = Enumerable.Select(Enumerable.Where(Enumerable.Select(targetShips, (Mem_ship target) => new
{
target = target,
submarineCheck = (subMarineFlag == stypes.get_Item(target.Stype).IsSubmarine())
}), <> __TranspIdent7 => < > __TranspIdent7.target.IsFight() && < > __TranspIdent7.submarineCheck), <> __TranspIdent7 => < > __TranspIdent7.target);
}
else
{
enumerable = Enumerable.Select(Enumerable.Where(Enumerable.Select(targetShips, (Mem_ship target) => new
{
target = target,
submarineCheck = (subMarineFlag == stypes.get_Item(target.Stype).IsSubmarine())
}), <> __TranspIdent8 => ! < > __TranspIdent8.target.Escape_sts && < > __TranspIdent8.submarineCheck), <> __TranspIdent8 => < > __TranspIdent8.target);
}
dKind = BattleDamageKinds.Normal;
if (enumerable == null || Enumerable.Count <Mem_ship>(enumerable) == 0)
{
return(null);
}
if (Enumerable.Count <Mem_ship>(enumerable) == 1)
{
return(Enumerable.First <Mem_ship>(enumerable));
}
List <Mem_ship> list;
if (attacker.IsEnemy())
{
list = this.targetFillter(this.E_SubInfo.get_Item(attacker.Rid).DeckIdx, enumerable, this.F_SubInfo);
}
else
{
list = this.targetFillter(this.F_SubInfo.get_Item(attacker.Rid).DeckIdx, enumerable, this.E_SubInfo);
}
Mem_ship mem_ship;
if (list.get_Count() == 0)
{
mem_ship = Enumerable.First <Mem_ship>(Enumerable.OrderBy <Mem_ship, Guid>(Enumerable.ToArray <Mem_ship>(enumerable), (Mem_ship x) => Guid.NewGuid()));
}
else
{
mem_ship = Enumerable.First <Mem_ship>(Enumerable.OrderBy <Mem_ship, Guid>(list, (Mem_ship x) => Guid.NewGuid()));
}
if (Enumerable.Count <Mem_ship>(enumerable) <= 1)
{
return(mem_ship);
}
Mem_ship flagShip = (!attacker.IsEnemy()) ? this.E_Data.ShipData.get_Item(0) : this.F_Data.ShipData.get_Item(0);
if (!rescueFlag || mem_ship.Rid != flagShip.Rid)
{
return(mem_ship);
}
Dictionary <int, Mst_ship> mShipDict = Mst_DataManager.Instance.Mst_ship;
Dictionary <int, Mst_stype> mStypeDict = Mst_DataManager.Instance.Mst_stype;
if (mStypeDict.get_Item(mem_ship.Stype).IsLandFacillity(mShipDict.get_Item(mem_ship.Ship_id).Soku))
{
return(mem_ship);
}
IEnumerable <Mem_ship> enumerable2 = Enumerable.Select(Enumerable.Where(Enumerable.Where(Enumerable.Where(Enumerable.Select(Enumerable.Select(enumerable, (Mem_ship re_target) => new
{
re_target = re_target,
mShipObj = mShipDict.get_Item(re_target.Ship_id)
}), <> __TranspIdent9 => new
{
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__(int damage, BattleHitStatus hitstate, BattleDamageKinds dmgkind)
{
_attackers.Add(null);
return(_AddData(damage, hitstate, dmgkind));
}
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);
}
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);
}
protected Mem_ship getAtackTarget(Mem_ship attacker, List <Mem_ship> targetShips, bool overKill, bool subMarineFlag, bool rescueFlag, ref BattleDamageKinds dKind)
{
Dictionary <int, Mst_stype> stypes = Mst_DataManager.Instance.Mst_stype;
IEnumerable <Mem_ship> enumerable = overKill ? (from target in targetShips
let submarineCheck = subMarineFlag == stypes[target.Stype].IsSubmarine()
where !target.Escape_sts && submarineCheck
select target) : (from target in targetShips
let submarineCheck = subMarineFlag == stypes[target.Stype].IsSubmarine()
where target.IsFight() && submarineCheck
select target);
dKind = BattleDamageKinds.Normal;
if (enumerable == null || enumerable.Count() == 0)
{
return(null);
}
if (enumerable.Count() == 1)
{
return(enumerable.First());
}
List <Mem_ship> list = (!attacker.IsEnemy()) ? targetFillter(F_SubInfo[attacker.Rid].DeckIdx, enumerable, E_SubInfo) : targetFillter(E_SubInfo[attacker.Rid].DeckIdx, enumerable, F_SubInfo);
Mem_ship mem_ship = (list.Count != 0) ? (from x in list
orderby Guid.NewGuid()
select x).First() : (from x in enumerable.ToArray()
orderby Guid.NewGuid()
select x).First();
if (enumerable.Count() <= 1)
{
return(mem_ship);
}
Mem_ship flagShip = (!attacker.IsEnemy()) ? E_Data.ShipData[0] : F_Data.ShipData[0];
if (!rescueFlag || mem_ship.Rid != flagShip.Rid)
{
return(mem_ship);
}
Dictionary <int, Mst_ship> mShipDict = Mst_DataManager.Instance.Mst_ship;
Dictionary <int, Mst_stype> mStypeDict = Mst_DataManager.Instance.Mst_stype;
if (mStypeDict[mem_ship.Stype].IsLandFacillity(mShipDict[mem_ship.Ship_id].Soku))
{
return(mem_ship);
}
IEnumerable <Mem_ship> source = from re_target in enumerable
let mShipObj = mShipDict[re_target.Ship_id]
let mStypeObj = mStypeDict[re_target.Stype]
where re_target.Get_DamageState() == DamageState.Normal
where !mStypeObj.IsLandFacillity(mShipObj.Soku)
where re_target.Rid != flagShip.Rid
select re_target;
if (!source.Any())
{
return(mem_ship);
}
BattleFormationKinds1 battleFormationKinds = (!mem_ship.IsEnemy()) ? F_Data.Formation : E_Data.Formation;
int num = 60;
switch (battleFormationKinds)
{
case BattleFormationKinds1.TanJuu:
num = 45;
break;
case BattleFormationKinds1.Rinkei:
num = 75;
break;
}
if (num > randInstance.Next(100))
{
return(mem_ship);
}
dKind = BattleDamageKinds.Rescue;
return((from x in source.ToArray()
orderby Guid.NewGuid()
select x).First());
}
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 = E_Data;
dictionary = E_SubInfo;
battleBaseData2 = F_Data;
dictionary2 = F_SubInfo;
func = base.RecoveryShip;
list = fSerchLightIdxs;
double eValance4 = eValance1;
double eValance5 = eValance2;
cliticalKeisu = eValance3;
}
else
{
battleBaseData = F_Data;
dictionary = F_SubInfo;
battleBaseData2 = E_Data;
dictionary2 = E_SubInfo;
list = eSerchLightIdxs;
double fValance4 = fValance1;
double fValance5 = fValance2;
cliticalKeisu = fValance3;
}
if (!isAttackerFromTargetKind(dictionary[attacker.Rid]))
{
return(null);
}
Hougeki <BattleAtackKinds_Night> hougeki = new Hougeki <BattleAtackKinds_Night>();
KeyValuePair <int, int> subMarineAtackKeisu = getSubMarineAtackKeisu(battleBaseData2.ShipData, attacker, battleBaseData.SlotData[atk_idx], midnight: true);
bool flag = false;
if (subMarineAtackKeisu.Key != 0)
{
hougeki.SpType = ((subMarineAtackKeisu.Key != 1) ? BattleAtackKinds_Night.AirAttack : BattleAtackKinds_Night.Bakurai);
hougeki.Slot_List.Add(0);
flag = true;
}
BattleDamageKinds dKind = BattleDamageKinds.Normal;
Mem_ship atackTarget = getAtackTarget(attacker, battleBaseData2.ShipData, overKill: false, flag, rescueFlag: true, ref dKind);
if (atackTarget == null)
{
return(null);
}
int deckIdx = dictionary2[atackTarget.Rid].DeckIdx;
if (atackTarget.Nowhp > 1 && list.Count > 0 && list[0] == deckIdx)
{
dKind = BattleDamageKinds.Normal;
atackTarget = getAtackTarget(attacker, battleBaseData2.ShipData, overKill: false, flag, rescueFlag: true, ref dKind);
deckIdx = dictionary2[atackTarget.Rid].DeckIdx;
}
if (!flag)
{
setSlotData(atk_idx, attacker, battleBaseData.SlotData[atk_idx], atackTarget, hougeki);
}
hougeki.Attacker = attacker.Rid;
int num = (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 < num; i++)
{
int soukou = atackTarget.Soukou;
List <Mst_slotitem> list2 = battleBaseData.SlotData[atk_idx];
int atkPow;
int hitProb;
FormationDatas.GetFormationKinds battleState;
if (flag)
{
atkPow = getSubmarineAttackValue(subMarineAtackKeisu, attacker, list2, battleBaseData.SlotLevel[atk_idx]);
hitProb = getSubmarineHitProb(attacker, battleBaseData.SlotData[atk_idx], battleBaseData.SlotLevel[atk_idx]);
battleState = FormationDatas.GetFormationKinds.SUBMARINE;
}
else
{
atkPow = getMidnightAttackValue(hougeki.SpType, attacker, list2, atackTarget);
hitProb = getMidnightHitProb(hougeki.SpType, attacker, list2, list);
battleState = FormationDatas.GetFormationKinds.MIDNIGHT;
}
int battleAvo_Midnight = getBattleAvo_Midnight(battleState, atackTarget, list.Contains(deckIdx));
BattleHitStatus battleHitStatus = getHitStatus(hitProb, battleAvo_Midnight, attacker, atackTarget, cliticalKeisu, airAttack: false);
if (battleHitStatus == BattleHitStatus.Miss && hashSet2.Contains(hougeki.SpType))
{
battleHitStatus = BattleHitStatus.Normal;
}
hougeki.Target.Add(atackTarget.Rid);
int item = setDamageValue(battleHitStatus, atkPow, soukou, attacker, atackTarget, battleBaseData2.LostFlag);
hougeki.Damage.Add(item);
hougeki.Clitical.Add(battleHitStatus);
hougeki.DamageKind.Add(dKind);
}
func?.Invoke(deckIdx);
return(hougeki);
}
public void __AddData__(int damage, BattleHitStatus hitstate, BattleDamageKinds dmgkind)
{
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);
}
public int __AddData__(ShipModel_BattleAll attacker, int damage, BattleHitStatus hitstate, BattleDamageKinds dmgkind)
{
this._attackers.Add(attacker.__CreateAttacker__());
return(base._AddData(damage, hitstate, dmgkind));
}
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 = this.e_AtkIdxs;
battleBaseData = this.E_Data;
dictionary = this.E_SubInfo;
battleBaseData2 = this.F_Data;
dictionary2 = this.F_SubInfo;
}
else
{
list = this.f_AtkIdxs;
battleBaseData = this.F_Data;
dictionary = this.F_SubInfo;
battleBaseData2 = this.E_Data;
dictionary2 = this.E_SubInfo;
}
int num = Enumerable.Count <int>(list);
if (num == 0)
{
return(raigekiInfo);
}
List <Mem_ship> list2 = Enumerable.ToList <Mem_ship>(battleBaseData2.ShipData);
Dictionary <int, Mst_stype> mst_stype = Mst_DataManager.Instance.Mst_stype;
Dictionary <int, Mst_ship> mst_ship = Mst_DataManager.Instance.Mst_ship;
list2.RemoveAll((Mem_ship x) => x.Nowhp <= 0 || mst_stype.get_Item(x.Stype).IsLandFacillity(mst_ship.get_Item(x.Ship_id).Soku));
if (list2.get_Count() == 0)
{
return(raigekiInfo);
}
for (int i = 0; i < num; i++)
{
int num2 = list.get_Item(i);
Mem_ship mem_ship = battleBaseData.ShipData.get_Item(num2);
List <Mst_slotitem> atk_slot = battleBaseData.SlotData.get_Item(num2);
if (this.isAttackerFromTargetKind(dictionary.get_Item(mem_ship.Rid)))
{
BattleDamageKinds battleDamageKinds = BattleDamageKinds.Normal;
Mem_ship atackTarget = base.getAtackTarget(mem_ship, list2, true, false, true, ref battleDamageKinds);
if (atackTarget != null)
{
int deckIdx = dictionary2.get_Item(atackTarget.Rid).DeckIdx;
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 num3 = this.setDamageValue(hitStatus, raigAttackValue, soukou, mem_ship, atackTarget, battleBaseData2.LostFlag);
raigekiInfo.Damage[num2] = num3;
raigekiInfo.Target[num2] = deckIdx;
raigekiInfo.DamageKind[num2] = battleDamageKinds;
raigekiInfo.Clitical[num2] = hitStatus;
}
}
}
return(raigekiInfo);
}
