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); }