Commit: 94be4bab0b1a434de72cfca303b0a5d98926f2ee - KancolleSniffer (git)

Commit MetaInfo

• Révision: 94be4bab0b1a434de72cfca303b0a5d98926f2ee (tree)
• l'heure: 2019-07-19 21:45:22
• Auteur: Kazuhiro Fujieda <fujieda@user...>
• Commiter: Kazuhiro Fujieda

Message de Log

基地航空隊の制空値周りをリファクタリングする

Change Summary

• modified: KancolleSniffer.Test/SnifferTest.cs
• modified: KancolleSniffer/KancolleSniffer.csproj
• modified: KancolleSniffer/Model/AirBase.cs
• delete: KancolleSniffer/Model/AirBaseParams.cs
• add: KancolleSniffer/Model/AirCorpsFighterPower.cs
• modified: KancolleSniffer/Model/ItemSpec.cs
• modified: KancolleSniffer/Model/ItemStatus.cs
• modified: KancolleSniffer/Sniffer.cs
• modified: KancolleSniffer/View/FleetSpec.cs

Modification

--- a/KancolleSniffer.Test/SnifferTest.cs
+++ b/KancolleSniffer.Test/SnifferTest.cs
@@ -113,9 +113,9 @@ namespace KancolleSniffer.Test
         {
             var sniffer = new Sniffer();
             SniffLogFile(sniffer, "airbase_001");
-            PAssert.That(() => (int)sniffer.AirBase[0].AirCorps[0].CalcFighterPower().Max.AirCombat == 301);
+            PAssert.That(() => sniffer.AirBase[0].AirCorps[0].CalcFighterPower().AirCombat.Max == 301);
             sniffer.AirBase[0].AirCorps[0].Action = 2; // 防空
-            PAssert.That(() => (int)sniffer.AirBase[0].AirCorps[0].CalcFighterPower().Max.Interception == 320);
+            PAssert.That(() => sniffer.AirBase[0].AirCorps[0].CalcFighterPower().Interception.Max == 320);
         }
 
         /// <summary>
@@ -126,7 +126,7 @@ namespace KancolleSniffer.Test
         {
             var sniffer = new Sniffer();
             SniffLogFile(sniffer, "airbase_002");
-            PAssert.That(() => (int)sniffer.AirBase[0].AirCorps[2].CalcFighterPower().Min.Interception == 353);
+            PAssert.That(() => sniffer.AirBase[0].AirCorps[2].CalcFighterPower().Interception.Min == 353);
         }
 
         /// <summary>
@@ -137,7 +137,7 @@ namespace KancolleSniffer.Test
         {
             var sniffer = new Sniffer();
             SniffLogFile(sniffer, "airbase_003");
-            PAssert.That(() => (int)sniffer.AirBase[1].AirCorps[0].CalcFighterPower().Min.AirCombat == 121);
+            PAssert.That(() => sniffer.AirBase[1].AirCorps[0].CalcFighterPower().AirCombat.Min == 121);
         }
 
         /// <summary>
@@ -159,7 +159,7 @@ namespace KancolleSniffer.Test
         {
             var sniffer = new Sniffer();
             SniffLogFile(sniffer, "airbase_004");
-            PAssert.That(() => (int)sniffer.AirBase[1].AirCorps[0].CalcFighterPower().Min.AirCombat == 328);
+            PAssert.That(() => sniffer.AirBase[1].AirCorps[0].CalcFighterPower().AirCombat.Min == 328);
         }
 
         /// <summary>
@@ -173,13 +173,13 @@ namespace KancolleSniffer.Test
 
             // 二式陸上偵察機(熟練)
             var fp1 = sniffer.AirBase[0].AirCorps[0].CalcFighterPower();
-            PAssert.That(() => (int)fp1.Min.AirCombat == 274);
-            PAssert.That(() => (int)fp1.Min.Interception == 302);
+            PAssert.That(() => fp1.AirCombat.Min == 274);
+            PAssert.That(() => fp1.Interception.Min == 302);
 
             // 二式陸上偵察機
             var fp3 = sniffer.AirBase[0].AirCorps[2].CalcFighterPower();
-            PAssert.That(() => (int)fp3.Min.AirCombat == 206);
-            PAssert.That(() => (int)fp3.Min.Interception == 310);
+            PAssert.That(() => fp3.AirCombat.Min == 206);
+            PAssert.That(() => fp3.Interception.Min == 310);
         }
 
         /// <summary>

--- a/KancolleSniffer/KancolleSniffer.csproj
+++ b/KancolleSniffer/KancolleSniffer.csproj
@@ -54,7 +54,7 @@
     <Reference Include="System.Xml" />
   </ItemGroup>
   <ItemGroup>
-    <Compile Include="Model\AirBaseParams.cs" />
+    <Compile Include="Model\AirCorpsFighterPower.cs" />
     <Compile Include="Model\QuestCounter.cs" />
     <Compile Include="Model\QuestCountList.cs" />
     <Compile Include="Model\QuestSpec.cs" />

--- a/KancolleSniffer/Model/AirBase.cs
+++ b/KancolleSniffer/Model/AirBase.cs
@@ -30,7 +30,7 @@ namespace KancolleSniffer.Model
             _itemInfo = item;
         }
 
-        public BaseInfo[] AllAirCorps { get; set; }
+        public BaseInfo[] AllBase { get; set; }
 
         public class BaseInfo
         {
@@ -75,20 +75,21 @@ namespace KancolleSniffer.Model
                 }
             }
 
-            public AirBaseParams.Range CalcFighterPower()
+            public AirCorpsFighterPower CalcFighterPower()
             {
-                var reconPlaneBonus = Planes.Aggregate(new AirBaseParams(), (max, plane) =>
+                var reconPlaneBonus = Planes.Aggregate(new AirCorpsFighterPower.Pair(), (max, plane) =>
                 {
                     var bonus = plane.Slot.Spec.ReconPlaneAirBaseBonus;
-                    return AirBaseParams.Max(max, bonus);
+                    return AirCorpsFighterPower.Pair.Max(max, bonus);
                 });
-                return (Planes.Aggregate(new AirBaseParams.Range(), (previous, plane) =>
+                var range = (Planes.Aggregate(new AirCorpsFighterPower.Range(), (previous, plane) =>
                 {
                     if (plane.State != 1)
                         return previous;
                     var current = plane.Slot.CalcFighterPowerInBase(plane.Count);
                     return previous + current;
                 }) * reconPlaneBonus).Floor();
+                return new AirCorpsFighterPower(range);
             }
 
             public int[] CostForSortie => Planes.Aggregate(new[] {0, 0}, (prev, plane) =>
@@ -135,12 +136,12 @@ namespace KancolleSniffer.Model
                 }
             }
 
-            public AirBaseParams.Range FighterPower => Slot.CalcFighterPowerInBase(Count);
+            public AirCorpsFighterPower FighterPower => new AirCorpsFighterPower(Slot.CalcFighterPowerInBase(Count));
         }
 
         public void Inspect(dynamic json)
         {
-            AllAirCorps = (from entry in (dynamic[])json
+            AllBase = (from entry in (dynamic[])json
                 group
                     new AirCorpsInfo
                     {
@@ -161,7 +162,7 @@ namespace KancolleSniffer.Model
 
         public void InspectSetPlane(string request, dynamic json)
         {
-            if (AllAirCorps == null)
+            if (AllBase == null)
                 return;
             var values = HttpUtility.ParseQueryString(request);
             var airCorps = GetBaseInfo(values).AirCorps[int.Parse(values["api_base_id"]) - 1];
@@ -195,7 +196,7 @@ namespace KancolleSniffer.Model
 
         public void InspectSetAction(string request)
         {
-            if (AllAirCorps == null)
+            if (AllBase == null)
                 return;
             var values = HttpUtility.ParseQueryString(request);
             var airCorps = GetBaseInfo(values).AirCorps;
@@ -224,7 +225,7 @@ namespace KancolleSniffer.Model
         private BaseInfo GetBaseInfo(NameValueCollection values)
         {
             var areaId = int.Parse(values["api_area_id"] ?? "0"); // 古いAPIに対応するため
-            return AllAirCorps.First(b => b.AreaId == areaId);
+            return AllBase.First(b => b.AreaId == areaId);
         }
 
         public void InspectPlaneInfo(dynamic json)
@@ -241,10 +242,10 @@ namespace KancolleSniffer.Model
 
         public void SetItemHolder()
         {
-            if (AllAirCorps == null)
+            if (AllBase == null)
                 return;
             var name = new[] {"第一", "第二", "第三"};
-            foreach (var baseInfo in AllAirCorps.Select((data, i) => new {data, i}))
+            foreach (var baseInfo in AllBase.Select((data, i) => new {data, i}))
             {
                 var areaName = baseInfo.data.AreaName;
                 foreach (var airCorps in baseInfo.data.AirCorps.Select((data, i) => new {data, i}))

--- a/KancolleSniffer/Model/AirBaseParams.cs
+++ /dev/null
@@ -1,95 +0,0 @@
-// Copyright (C) 2019 Kazuhiro Fujieda <[e-mail]>
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//    http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-using System;
-using KancolleSniffer.Util;
-
-namespace KancolleSniffer.Model
-{
-    public struct AirBaseParams
-    {
-        public double AirCombat { get; }
-        public double Interception { get; }
-
-        public AirBaseParams(double airCombat, double interception)
-        {
-            AirCombat = airCombat;
-            Interception = interception;
-        }
-
-        public static AirBaseParams Max(AirBaseParams value1, AirBaseParams value2)
-        {
-            return new AirBaseParams(Math.Max(value1.AirCombat, value2.AirCombat),
-                Math.Max(value1.Interception, value2.Interception));
-        }
-
-        public static AirBaseParams operator +(AirBaseParams lhs, AirBaseParams rhs)
-        {
-            return new AirBaseParams(lhs.AirCombat + rhs.AirCombat, lhs.Interception + rhs.Interception);
-        }
-
-        public static AirBaseParams operator +(AirBaseParams lhs, double rhs)
-        {
-            return new AirBaseParams(lhs.AirCombat + rhs, lhs.Interception + rhs);
-        }
-
-        public static AirBaseParams operator *(AirBaseParams lhs, AirBaseParams rhs)
-        {
-            return new AirBaseParams(lhs.AirCombat * rhs.AirCombat, lhs.Interception * rhs.Interception);
-        }
-
-        public static AirBaseParams operator *(AirBaseParams lhs, double rhs)
-        {
-            return new AirBaseParams(lhs.AirCombat * rhs, lhs.Interception * rhs);
-        }
-
-        public AirBaseParams Floor()
-        {
-            return new AirBaseParams((int)AirCombat, (int)Interception);
-        }
-
-        public struct Range
-        {
-            public AirBaseParams Min { get; }
-            public AirBaseParams Max { get; }
-
-            public Range(AirBaseParams min, AirBaseParams max)
-            {
-                Min = min;
-                Max = max;
-            }
-
-            public Range(AirBaseParams base_, RangeD range)
-            {
-                Min = (base_ + range.Min).Floor();
-                Max = (base_ + range.Max).Floor();
-            }
-
-            public static Range operator +(Range lhs, Range rhs)
-            {
-                return new Range(lhs.Min + rhs.Min, lhs.Max + rhs.Max);
-            }
-
-            public static Range operator *(Range lhs, AirBaseParams rhs)
-            {
-                return new Range(lhs.Min * rhs, lhs.Max * rhs);
-            }
-
-            public Range Floor()
-            {
-                return new Range(Min.Floor(), Max.Floor());
-            }
-        }
-    }
-}
\ No newline at end of file

--- /dev/null
+++ b/KancolleSniffer/Model/AirCorpsFighterPower.cs
@@ -0,0 +1,108 @@
+// Copyright (C) 2019 Kazuhiro Fujieda <[e-mail]>
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+using System;
+
+namespace KancolleSniffer.Model
+{
+    public class AirCorpsFighterPower
+    {
+        public Model.Range AirCombat;
+        public Model.Range Interception;
+        public bool Difference;
+
+        public AirCorpsFighterPower(Range fighterPower)
+        {
+            AirCombat = new Model.Range(fighterPower.Min.AirCombat, fighterPower.Max.AirCombat);
+            Interception = new Model.Range(fighterPower.Min.Interception, fighterPower.Max.Interception);
+            Difference = Interception.Min != AirCombat.Min;
+        }
+
+        public struct Pair
+        {
+            public double AirCombat { get; }
+            public double Interception { get; }
+
+            public Pair(double airCombat, double interception)
+            {
+                AirCombat = airCombat;
+                Interception = interception;
+            }
+
+            public static Pair Max(Pair value1, Pair value2)
+            {
+                return new Pair(Math.Max(value1.AirCombat, value2.AirCombat),
+                    Math.Max(value1.Interception, value2.Interception));
+            }
+
+            public static Pair operator +(Pair lhs, Pair rhs)
+            {
+                return new Pair(lhs.AirCombat + rhs.AirCombat, lhs.Interception + rhs.Interception);
+            }
+
+            public static Pair operator +(Pair lhs, double rhs)
+            {
+                return new Pair(lhs.AirCombat + rhs, lhs.Interception + rhs);
+            }
+
+            public static Pair operator *(Pair lhs, Pair rhs)
+            {
+                return new Pair(lhs.AirCombat * rhs.AirCombat, lhs.Interception * rhs.Interception);
+            }
+
+            public static Pair operator *(Pair lhs, double rhs)
+            {
+                return new Pair(lhs.AirCombat * rhs, lhs.Interception * rhs);
+            }
+
+            public Pair Floor()
+            {
+                return new Pair((int)AirCombat, (int)Interception);
+            }
+        }
+
+        public struct Range
+        {
+            public Pair Min { get; }
+            public Pair Max { get; }
+
+            public Range(Pair min, Pair max)
+            {
+                Min = min;
+                Max = max;
+            }
+
+            public Range(Pair base_, RangeD range)
+            {
+                Min = (base_ + range.Min).Floor();
+                Max = (base_ + range.Max).Floor();
+            }
+
+            public static Range operator +(Range lhs, Range rhs)
+            {
+                return new Range(lhs.Min + rhs.Min, lhs.Max + rhs.Max);
+            }
+
+            public static Range operator *(Range lhs, Pair rhs)
+            {
+                return new Range(lhs.Min * rhs, lhs.Max * rhs);
+            }
+
+            public Range Floor()
+            {
+                return new Range(Min.Floor(), Max.Floor());
+            }
+        }
+    }
+}
\ No newline at end of file

--- a/KancolleSniffer/Model/ItemSpec.cs
+++ b/KancolleSniffer/Model/ItemSpec.cs
@@ -204,21 +204,21 @@ namespace KancolleSniffer.Model
             }
         }
 
-        public AirBaseParams ReconPlaneAirBaseBonus
+        public AirCorpsFighterPower.Pair ReconPlaneAirBaseBonus
         {
             get
             {
                 switch (Type)
                 {
                     case 9:
-                        return new AirBaseParams(1.0, LoS <= 7 ? 1.2 : 1.3);
+                        return new AirCorpsFighterPower.Pair(1.0, LoS <= 7 ? 1.2 : 1.3);
                     case 10:
                     case 41:
-                        return new AirBaseParams(1.0, LoS <= 7 ? 1.1 : LoS <= 8 ? 1.13 : 1.16);
+                        return new AirCorpsFighterPower.Pair(1.0, LoS <= 7 ? 1.1 : LoS <= 8 ? 1.13 : 1.16);
                     case 49:
-                        return new AirBaseParams(LoS <= 8 ? 1.15 : 1.18, LoS <= 8 ? 1.18 : 1.24);
+                        return new AirCorpsFighterPower.Pair(LoS <= 8 ? 1.15 : 1.18, LoS <= 8 ? 1.18 : 1.24);
                 }
-                return new AirBaseParams(1.0, 1.0);
+                return new AirCorpsFighterPower.Pair(1.0, 1.0);
             }
         }
 

--- a/KancolleSniffer/Model/ItemStatus.cs
+++ b/KancolleSniffer/Model/ItemStatus.cs
@@ -56,14 +56,14 @@ namespace KancolleSniffer.Model
             }
         }
 
-        public AirBaseParams.Range CalcFighterPowerInBase(int slot)
+        public AirCorpsFighterPower.Range CalcFighterPowerInBase(int slot)
         {
             if (!Spec.IsAircraft || slot == 0)
-                return new AirBaseParams.Range();
+                return new AirCorpsFighterPower.Range();
             var withoutAlv =
-                (new AirBaseParams(Spec.Interception * 1.5, Spec.AntiBomber * 2 + Spec.Interception) +
+                (new AirCorpsFighterPower.Pair(Spec.Interception * 1.5, Spec.AntiBomber * 2 + Spec.Interception) +
                  Spec.AntiAir + FighterPowerLevelBonus) * Math.Sqrt(slot);
-            return new AirBaseParams.Range(withoutAlv, AlvBonusInBase);
+            return new AirCorpsFighterPower.Range(withoutAlv, AlvBonusInBase);
         }
 
         private RangeD AlvBonusInBase

--- a/KancolleSniffer/Sniffer.cs
+++ b/KancolleSniffer/Sniffer.cs
@@ -657,7 +657,7 @@ namespace KancolleSniffer
 
         public string MiscText => _miscTextInfo.Text;
 
-        public AirBase.BaseInfo[] AirBase => _airBase.AllAirCorps;
+        public AirBase.BaseInfo[] AirBase => _airBase.AllBase;
 
         public CellInfo CellInfo => _cellInfo;
 

--- a/KancolleSniffer/View/FleetSpec.cs
+++ b/KancolleSniffer/View/FleetSpec.cs
@@ -246,7 +246,7 @@ namespace KancolleSniffer.View
             {
                 public AirCorpsRecord(AirBase.AirCorpsInfo airCorps, int number)
                 {
-                    var corpsFp = new AirCorpsFp(airCorps.CalcFighterPower());
+                    var corpsFp = airCorps.CalcFighterPower();
                     string spec;
                     string spec2;
                     if (airCorps.Action == 2)
@@ -276,7 +276,7 @@ namespace KancolleSniffer.View
             {
                 public CorpsPlaneRecord(AirBase.PlaneInfo plane)
                 {
-                    var planeFp = new AirCorpsFp(plane.FighterPower);
+                    var planeFp = plane.FighterPower;
                     Equip = plane.State != 1 ? plane.StateName : GenEquipString(plane.Slot);
                     Spec = plane.State != 1 ? "" : $"+{plane.Slot.Alv} {plane.Count}/{plane.MaxCount}";
                     AircraftSpec =
@@ -286,20 +286,6 @@ namespace KancolleSniffer.View
                 }
             }
 
-            private class AirCorpsFp
-            {
-                public readonly Range AirCombat;
-                public readonly Range Interception;
-                public readonly bool Difference;
-
-                public AirCorpsFp(AirBaseParams.Range fighterPower)
-                {
-                    AirCombat = new Range(fighterPower.Min.AirCombat, fighterPower.Max.AirCombat);
-                    Interception = new Range(fighterPower.Min.Interception, fighterPower.Min.Interception);
-                    Difference = Interception.Min != AirCombat.Min;
-                }
-            }
-
             private static string RangeString(Range range) => range.Diff ? range.RangeString : range.Min.ToString();
         }
     }