Esempio n. 1
0
        public T GetResultData <T>(FormationDatas formation) where T : Support_HouRai
        {
            formationData = formation;
            Support_HouRai raigekiData = getRaigekiData();

            return((T)raigekiData);
        }
Esempio n. 2
0
        public T GetResultData <T>(FormationDatas formation) where T : Support_HouRai, new()
        {
            this.formationData = formation;
            Support_HouRai hougekiData = this.getHougekiData();

            return((T)((object)hougekiData));
        }
Esempio n. 3
0
        public T GetResultData <T>(FormationDatas formation) where T : Support_HouRai, new()
        {
            formationData = formation;
            Support_HouRai hougekiData = getHougekiData();

            return((T)hougekiData);
        }
        public T GetResultData <T>(FormationDatas formation) where T : Support_HouRai
        {
            this.formationData = formation;
            Support_HouRai raigekiData = this.getRaigekiData();

            return((T)((object)raigekiData));
        }
Esempio n. 5
0
        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);
        }
Esempio n. 7
0
        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);
        }
Esempio n. 8
0
        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);
        }