Merge pull request #304 from asdawej/chore

refactor: check property & refactor `Cal` to `LadderCalculate`

Author: asdawej

logic/GameClass/GameClassLogging.cs

@@ -3,6 +3,11 @@
 
 namespace GameClass.GameObj
 {
+    public static class GameObjLogger
+    {
+        public static readonly Logger logger = new("GameObj");
+    }
+
     public static class LoggingFunctional
     {
         public static string ShipLogInfo(Ship ship)

logic/GameClass/GameObj/Areas/Resource.cs

@@ -8,7 +8,7 @@ namespace GameClass.GameObj.Areas;
 public class Resource(XY initPos)
     : Immovable(initPos, GameData.NumOfPosGridPerCell / 2, GameObjType.Resource)
 {
-    public InVariableRange<long> HP { get; } = new InVariableRange<long>(GameData.ResourceHP);
+    public InVariableRange<long> HP { get; } = new(GameData.ResourceHP);
     public override bool IsRigid => true;
     public override ShapeType Shape => ShapeType.Square;
     public AtomicInt ProduceNum { get; } = new AtomicInt(0);

logic/GameClass/GameObj/Areas/Wormhole.cs

@@ -7,7 +7,7 @@ namespace GameClass.GameObj.Areas;
 
 public class Wormhole(List<WormholeCell> cells, int id)
 {
-    public InVariableRange<long> HP = new(GameData.WormholeHP);
+    public InVariableRange<long> HP { get; } = new(GameData.WormholeHP);
     private readonly List<WormholeCell> cells = cells;
     public List<WormholeCell> Cells => cells;
     public AtomicInt RepairNum { get; } = new AtomicInt(0);

logic/GameClass/GameObj/Base.cs

@@ -37,16 +37,12 @@ public Base(Home home)
                     }
                     return false;
                 },
-                activator: (ship) =>
-                {
-                    ship.CanMove.SetROri(true);
-                    ship.IsRemoved.SetROri(false);
-                },
                 inactivator: (ship) =>
                 {
                     ship.CanMove.SetROri(false);
                     ship.IsRemoved.SetROri(true);
                 });
+            // 池初始化，但是由于服务器采用逐个添加船只的方式，因此这里不进行任何行为
             ShipPool.Initiate(ShipType.CivilShip, 0,
                               () => new(GameData.ShipRadius, ShipType.CivilShip, MoneyPool));
             ShipPool.Initiate(ShipType.WarShip, 0,

logic/GameClass/GameObj/GameObj.cs

@@ -7,10 +7,6 @@
 
 namespace GameClass.GameObj
 {
-    public static class GameObjLogger
-    {
-        public static readonly Logger logger = new("GameObj");
-    }
     /// <summary>
     /// 一切游戏元素的总基类，与THUAI4不同，继承IMoveable接口（出于一切物体其实都是可运动的指导思想）——LHR
     /// </summary>

logic/GameClass/GameObj/Ship.cs

@@ -46,7 +46,7 @@ public ShipStateType ShipState
     /// <summary>
     /// 子弹数上限, THUAI7为无穷
     /// </summary>
-    public IntNumUpdateEachCD BulletNum => new(int.MaxValue, 1);
+    public IntNumUpdateEachCD BulletNum { get; } = new(int.MaxValue, 1);
     /// <summary>
     /// 模块相关
     /// </summary>

logic/Preparation/Utility/Value/SafeValue/ObjPool.cs

@@ -7,7 +7,6 @@ namespace Preparation.Utility.Value.SafeValue;
 public class ObjPool<T, TType>(Func<T, TType> classfier,
                                Func<T, bool> idleChecker,
                                Func<T, bool> tryActivator,
-                               Action<T> activator,
                                Action<T> inactivator)
     : IObjPool<T, TType>
     where T : class
@@ -18,7 +17,6 @@ public class ObjPool<T, TType>(Func<T, TType> classfier,
     private readonly Func<T, TType> classfier = classfier;
     private readonly Func<T, bool> idleChecker = idleChecker;
     private readonly Func<T, bool> tryActivator = tryActivator;
-    private readonly Action<T> activator = activator;
     private readonly Action<T> inactivator = inactivator;
 
     #region 属性

logic/Server/GameServer.cs

@@ -133,73 +133,69 @@ protected async Task<double[]> GetLadderScore(double[] scores)
                     // 解析 JSON 字符串
                     var result = JsonConvert.DeserializeObject<List<ContestResult>>(jsonString);
                     double[] org = (from r in result select (double)(r.score)).ToArray();
-                    double[] final = Cal(org, scores);
+                    double[] final = LadderCalculate(org, scores);
                     return final;
                 }
                 catch (Exception e)
                 {
                     GameServerLogging.logger.ConsoleLog("No response from ladder URL!");
                     GameServerLogging.logger.ConsoleLog(e.ToString());
-                    return new double[0];
+                    return [];
                 }
             }
             else
             {
                 GameServerLogging.logger.ConsoleLog("Null URL!");
-                return new double[0];
+                return [];
             }
         }
 
-        protected double[] Cal(double[] orgScore, double[] competitionScore)
+        protected static double[] LadderCalculate(double[] oriScores, double[] competitionScores)
         {
-            // 调整顺序，让第一个元素成为获胜者，便于计算
-            bool reverse = false; // 记录是否需要调整
-            if (competitionScore[0] < competitionScore[1])
+            // 调整顺序，让第一项成为获胜者，便于计算
+            bool scoresReverse = false; // 顺序是否需要交换
+            if (competitionScores[0] < competitionScores[1])      // 第一项为落败者
+                scoresReverse = true;
+            else if (competitionScores[0] == competitionScores[1])// 平局
             {
-                reverse = true;
-            }
-            else if (competitionScore[0] == competitionScore[1])
-            {
-                if (orgScore[0] == orgScore[1])
-                {
+                if (oriScores[0] == oriScores[1])
                     // 完全平局，不改变天梯分数
-                    return orgScore;
-                }
-                if (orgScore[0] > orgScore[1])
-                {
-                    // 本次游戏平局，但一方天梯分数高，另一方天梯分数低，需要将两者向中间略微靠拢，因此天梯分数低的定为获胜者
-                    reverse = true;
-                }
+                    return oriScores;
+                if (oriScores[0] > oriScores[1])
+                    // 本次游戏平局，但一方天梯分数高，另一方天梯分数低，
+                    // 需要将两者向中间略微靠拢，因此天梯分数低的定为获胜者
+                    scoresReverse = true;
             }
-            if (reverse)
+            if (scoresReverse)// 如果需要换，交换两者的顺序
             {
-                // 如果需要换，换两者的顺序
-                double t = competitionScore[1];
-                competitionScore[1] = competitionScore[0];
-                competitionScore[0] = t;
-                t = orgScore[1];
-                orgScore[1] = orgScore[0];
-                orgScore[0] = t;
+                (competitionScores[0], competitionScores[1]) = (competitionScores[1], competitionScores[0]);
+                (oriScores[0], oriScores[1]) = (oriScores[1], oriScores[0]);
             }
+
+            const double normalDeltaThereshold = 1000.0;            // 分数差标准化参数，同时也是大分数差阈值
+            const double correctParam = normalDeltaThereshold * 1.2;// 修正参数
+            const double winnerWeight = 9e-6;                       // 获胜者天梯得分权值
+            const double loserWeight = 5e-6;                        // 落败者天梯得分权值
+            const double scoreDeltaThereshold = 2100.0;             // 极大分数差阈值
+
             double[] resScore = [0, 0];
-            double deltaWeight = 1000.0; // 差距悬殊判断参数
-            double delta = (orgScore[0] - orgScore[1]) / deltaWeight;
-            // 盈利者天梯得分权值、落败者天梯得分权值
-            double firstnerGet = 9e-6;
-            double secondrGet = 5e-6;
-            double deltaScore = 2100.0; // 两队竞争分差超过多少时就认为非常大
-            double correctRate = (orgScore[0] - orgScore[1]) / (deltaWeight * 1.2); // 订正的幅度，该值越小，则在势均力敌时天梯分数改变越大
-            double correct = 0.5 * (Math.Tanh((competitionScore[0] - competitionScore[1] - deltaScore) / deltaScore - correctRate) + 1.0); // 一场比赛中，在双方势均力敌时，减小天梯分数的改变量
-            resScore[0] = orgScore[0] + Math.Round(competitionScore[0] * competitionScore[0] * firstnerGet * (1 - Math.Tanh(delta)) * correct); // 胜者所加天梯分
-            resScore[1] = orgScore[1] - Math.Round(
-            (competitionScore[0] - competitionScore[1]) * (competitionScore[0] - competitionScore[1]) * secondrGet * (1 - Math.Tanh(delta)) * correct); // 败者所扣天梯分
-                                                                                                                                                        // 如果换过，再换回来
-            if (reverse)
-            {
-                double t = resScore[1];
-                resScore[1] = resScore[0];
-                resScore[0] = t;
-            }
+            double oriDelta = oriScores[0] - oriScores[1];                          // 原分数差
+            double competitionDelta = competitionScores[0] - competitionScores[1];  // 本次比赛分数差
+            double normalOriDelta = oriDelta / normalDeltaThereshold;               // 标准化原分数差
+            double correctRate = oriDelta / correctParam;                           // 修正率，修正方向为缩小分数差
+            double correct = 0.5 * (Math.Tanh((competitionDelta - scoreDeltaThereshold) / scoreDeltaThereshold
+                                              - correctRate)
+                                    + 1.0); // 分数修正
+            resScore[0] = oriScores[0] + Math.Round(Math.Pow(competitionScores[0], 2)
+                                                    * winnerWeight
+                                                    * (1 - Math.Tanh(normalOriDelta))
+                                                    * correct); // 胜者所加天梯分
+            resScore[1] = oriScores[1] - Math.Round(Math.Pow(competitionDelta, 2)
+                                                    * loserWeight
+                                                    * (1 - Math.Tanh(normalOriDelta))
+                                                    * correct); // 败者所扣天梯分
+            if (scoresReverse)// 顺序换回
+                (resScore[0], resScore[1]) = (resScore[1], resScore[0]);
             return resScore;
         }