Example #1
0
        public ECFireCombat(OldBattle battle, sortie_battle_old.fire api)
        {
            var result = new List <Attack>();

            for (int i = 0; i < api.api_df_list.Length; i++)
            {
                int  sourceidx = api.api_at_list[i + 1];
                bool direction = api.api_at_eflag[i + 1] == 0;
                var  source    = direction ?
                                 FindShip(sourceidx, battle.Fleet1, battle.Fleet2) :
                                 FindShip(sourceidx, battle.EnemyFleet, battle.EnemyFleet2);
                for (int j = 0; j < api.api_df_list[i].Length; j++)
                {
                    int destidx = api.api_df_list[i][j];
                    var dest    = direction ?
                                  FindShip(destidx, battle.EnemyFleet, battle.EnemyFleet2) :
                                  FindShip(destidx, battle.Fleet1, battle.Fleet2);
                    var damage = Attack.ParseDamage(api.api_damage[i][j]);
                    (var friend, var enemy) = direction ? (source, dest) : (dest, source);
                    result.Add(new Attack
                    {
                        Friend     = friend,
                        Enemy      = enemy,
                        Direction  = direction,
                        Damage     = damage.damage,
                        IsCritical = api.api_cl_list[i][j] == 2,
                        Shield     = damage.shield
                    });
                }
            }
            ApplyAttacks(result);
        }
Example #2
0
 public SupportAttack(OldBattle battle, sortie_battle_old.support api, int type)
 {
     Type = (SupportType)type;
     if (Type == SupportType.Aerial)
     {
         Aerial = new AerialSupport(battle, api.api_support_airatack);
     }
     else
     {
         var result = new List <Attack>();
         for (int i = 1; i < api.api_support_hourai.api_damage.Length; i++)
         {
             var damage = Attack.ParseDamage(api.api_support_hourai.api_damage[i]);
             if (damage.damage == 0 && !damage.shield)
             {
                 continue;
             }
             result.Add(new Attack
             {
                 Friend     = null,
                 Enemy      = FindShip(i, battle.EnemyFleet, battle.EnemyFleet2),
                 Direction  = true,
                 Damage     = damage.damage,
                 Shield     = damage.shield,
                 IsCritical = api.api_support_hourai.api_cl_list[i] == 2
             });
         }
         ApplyAttacks(result);
     }
 }
Example #3
0
 public AntiAirCutin(OldBattle battle, sortie_battle_old.airbattle.stage2.anti_air_cutin api)
 {
     if (api.api_idx < 6)
     {
         Ship = battle.Fleet1[api.api_idx];
     }
     else
     {
         Ship = battle.Fleet2[api.api_idx - 6];
     }
     Type      = api.api_kind;
     EquipList = api.api_use_items.Select(x => Staff.Current.MasterData.EquipInfo[x]).ToArray();
 }
Example #4
0
        public AirBaseAttack(OldBattle battle, sortie_battle_old.airbattle api) : base(api)
        {
            //SquadronList = api.api_squadron_plane.Select(x => new Squadron
            //{
            //    Plane = Staff.Current.MasterData.EquipInfo[x.api_mst_id],
            //    Count = x.api_count
            //}).ToArray();
            if (api.api_stage1 != null)
            {
                AirControl = (AirControl)api.api_stage1.api_disp_seiku;
            }

            ParseAttacks(battle, api, null, null, null, null);
        }
Example #5
0
        public AerialSupport(OldBattle battle, sortie_battle_old.airbattle api) : base(api)
        {
            if (api.api_stage1 != null)
            {
                AirControl = (AirControl)api.api_stage1.api_disp_seiku;
            }

            ShipInBattle enemytorpedo = null, enemybomb = null;

            enemytorpedo = battle.EnemyFleet.Where(x => x.CanAerialTorpedo).TakeIfSingle();
            enemybomb    = battle.EnemyFleet.Where(x => x.CanAerialBomb).TakeIfSingle();

            ParseAttacks(battle, api, null, null, enemytorpedo, enemybomb);
        }
Example #6
0
        public JetPlaneAttack(OldBattle battle, sortie_battle_old.airbattle api, bool isSupport) : base(api)
        {
            ShipInBattle friendjet = null, enemyjet = null;

            if (!isSupport)
            {
                if (api.api_plane_from[0]?.Length == 1 && api.api_plane_from[0][0] > 0)
                {
                    friendjet = battle.Fleet1[api.api_plane_from[0][0] - 1];
                }
                if (api.api_plane_from.Length >= 2 && api.api_plane_from[1]?.Length == 1 && api.api_plane_from[1][0] > 0)
                {
                    enemyjet = battle.EnemyFleet[api.api_plane_from[1][0] - 1];
                }
            }
            ParseAttacks(battle, api, null, friendjet, null, enemyjet);
        }
Example #7
0
        public ECTorpedoCombat(OldBattle battle, sortie_battle_old.torpedo api)
        {
            var result = new List <Attack>();

            for (int i = 1; i < api.api_fydam.Length; i++)
            {
                int target = api.api_frai[i];
                if (target == 0)
                {
                    continue;
                }
                var damage = Attack.ParseDamage(api.api_fydam[i]);
                result.Add(new Attack
                {
                    Friend     = FindShip(i, battle.Fleet1, battle.Fleet2),
                    Enemy      = FindShip(target, battle.EnemyFleet, battle.EnemyFleet2),
                    Direction  = true,
                    Damage     = damage.damage,
                    Shield     = damage.shield,
                    IsCritical = api.api_fcl[i] == 2
                });
            }
            for (int i = 1; i < api.api_eydam.Length; i++)
            {
                int target = api.api_erai[i];
                if (target == 0)
                {
                    continue;
                }
                var damage = Attack.ParseDamage(api.api_eydam[i]);
                result.Add(new Attack
                {
                    Friend     = FindShip(target, battle.Fleet1, battle.Fleet2),
                    Enemy      = FindShip(i, battle.EnemyFleet, battle.EnemyFleet2),
                    Direction  = false,
                    Damage     = damage.damage,
                    Shield     = damage.shield,
                    IsCritical = api.api_ecl[i] == 2
                });
            }
            ApplyAttacks(result);
        }
Example #8
0
        public AerialCombat(OldBattle battle, sortie_battle_old.airbattle api) : base(api)
        {
            if (api.api_stage1 != null)
            {
                AirControl  = (AirControl)api.api_stage1.api_disp_seiku;
                FriendTouch = Staff.Current.MasterData.EquipInfo[api.api_stage1.api_touch_plane[0]];
                EnemyTouch  = Staff.Current.MasterData.EquipInfo[api.api_stage1.api_touch_plane[1]];
            }

            if (api.api_stage2?.api_air_fire != null)
            {
                AntiAir = new AntiAirCutin(battle, api.api_stage2.api_air_fire);
            }

            ShipInBattle friendtorpedo = null, friendbomb = null, enemytorpedo = null, enemybomb = null;

            friendtorpedo = battle.Fleet1.Where(x => x.CanAerialTorpedo).TakeIfSingle();
            friendbomb    = battle.Fleet1.Where(x => x.CanAerialBomb).TakeIfSingle();
            enemytorpedo  = battle.EnemyFleet.Where(x => x.CanAerialTorpedo).TakeIfSingle();
            enemybomb     = battle.EnemyFleet.Where(x => x.CanAerialBomb).TakeIfSingle();

            ParseAttacks(battle, api, friendtorpedo, friendbomb, enemytorpedo, enemybomb);
        }
Example #9
0
        public BattleDetailViewModel ToViewModel(BattleDropLog log)
        {
            ShipInBattle[] fleet1, fleet2;
            EquipInBattle EquipSelector(EquipInfo equip)
            => equip != null ?
            new EquipInBattle(Staff.Current.MasterData.EquipInfo[equip.itemid])
            {
                ImproveLevel   = equip.level,
                AirProficiency = equip.alv
            } : null;
            fleet1 = this.fleet1?.Select((ship, i) => new ShipInBattle
            {
                Index      = i + 1,
                Level      = ship.lv,
                ShipInfo   = Staff.Current.MasterData.ShipInfo[ship.shipid],
                Firepower  = ship.karyoku,
                Torpedo    = ship.raisou,
                AA         = ship.taiku,
                Armor      = ship.soukou,
                Equipments = ship.slots.Where(x => x != null)
                             .Select(EquipSelector).ToArray(),
                EquipmentEx = EquipSelector(ship.slotex)
            }).ToArray();
            fleet2 = this.fleet2?.Select((ship, i) => new ShipInBattle
            {
                Index      = i + 7,
                Level      = ship.lv,
                ShipInfo   = Staff.Current.MasterData.ShipInfo[ship.shipid],
                Firepower  = ship.karyoku,
                Torpedo    = ship.raisou,
                AA         = ship.taiku,
                Armor      = ship.soukou,
                Equipments = ship.slots.Where(x => x != null)
                             .Select(EquipSelector).ToArray(),
                EquipmentEx = EquipSelector(ship.slotex)
            }).ToArray();
            var node = new MapNode(startnext.data.api_data);

            //CombinedFleetType type;
            //if (!apimap.TryGetValue(battle.api, out type) && fleet2 != null)//broken log
            //{
            //    if (DispatcherHelper.UIDispatcher.Invoke(() =>
            //        MessageBox.Show("记录损坏。请问要将该场战斗作为机动/运输部队解析吗?", "记录损坏", MessageBoxButton.YesNo)) == MessageBoxResult.Yes)
            //        type = CombinedFleetType.Carrier;
            //    else type = CombinedFleetType.Surface;
            //}

            void PatchEnemyId(int[] enemy)
            {
                if (enemy == null)
                {
                    return;
                }
                for (int i = 0; i < enemy.Length; i++)
                {
                    if (enemy[i] > 500 && enemy[i] <= 1500)
                    {
                        enemy[i] += 1000;
                    }
                }
            }

            if (log.DateTime < idChangeStamp)
            {
                PatchEnemyId(battle.data.api_data.api_ship_ke);
                PatchEnemyId(battle.data.api_data.api_ship_ke_combined);
            }

            apimap.TryGetValue(battle.api, out var type);
            var result = new OldBattle(battle.data.api_data, type, node.Type, fleet1, fleet2);

            if (nightbattle != null)
            {
                result.NightBattle(nightbattle.data.api_data);
            }
            return(new BattleDetailViewModel
            {
                Log = log,
                Node = node,
                Battle = result,
                Time = new DateTimeOffset(GetTimeStamp(), TimeSpan.Zero)
            });
        }