Merge pull request #242 from shangfengh/new

build: 🚧 edit the data about Occupations

logic/GameClass/GameObj/Character/Character.cs

@@ -472,7 +472,7 @@ namespace GameClass.GameObj
             return indexing;
         }
 
-        public void AddMoveSpeed(int buffTime, double add = 2.0) => buffManager.AddMoveSpeed(add, buffTime, newVal =>
+        public void AddMoveSpeed(int buffTime, double add = 1.0) => buffManager.AddMoveSpeed(add, buffTime, newVal =>
                                                                                                             { MoveSpeed = newVal < GameData.characterMaxSpeed ? newVal : GameData.characterMaxSpeed; },
                                                                                              OrgMoveSpeed);
         public bool HasFasterSpeed => buffManager.HasFasterSpeed;

logic/Gaming/ActionManager.cs

@@ -245,7 +245,7 @@ namespace Gaming
                     return false;
                 Chest? chestToOpen = (Chest?)gameMap.OneForInteract(player.Position, GameObjType.Chest);
 
-                if (chestToOpen == null || chestToOpen.IsOpen() || chestToOpen.OpenDegree > 0)
+                if (chestToOpen == null || chestToOpen.OpenDegree > 0)
                     return false;
 
                 player.PlayerState = PlayerStateType.OpeningTheChest;

logic/Gaming/CharacterManager .cs

@@ -134,7 +134,7 @@ namespace Gaming
                                         {
                                             if (!noise && XY.Distance(newPlayer.Position, person.Position) <= (newPlayer.AlertnessRadius / person.Concealment))
                                                 newPlayer.AddBgm(BgmType.GhostIsComing, (double)newPlayer.AlertnessRadius / XY.Distance(newPlayer.Position, person.Position));
-                                            if (newPlayer.CharacterType != CharacterType.Teacher && XY.Distance(newPlayer.Position, person.Position) <= GameData.basicViewRange)
+                                            if (newPlayer.CharacterType != CharacterType.Teacher && XY.Distance(newPlayer.Position, person.Position) <= newPlayer.ViewRange)
                                             {
                                                 TimePinningDown += GameData.checkInterval;
                                                 newPlayer.AddScore(GameData.StudentScorePinDown(TimePinningDown) - ScoreAdded);

logic/Gaming/SkillManager/SkillManager.ActiveSkill.cs

@@ -239,8 +239,8 @@ namespace Gaming
                         {
                             if (gameMap.CanSee(player, character))
                             {
-                                player.AddScore(GameData.StudentScoreTreat(character.MaxHp - character.HP));
-                                character.AddMoveSpeed(GameData.PropDuration);
+                                player.AddScore(GameData.ScoreInspire);
+                                character.AddMoveSpeed(GameData.TimeOfAddingSpeedWhenInspire, GameData.AddedTimeOfSpeedWhenInspire);
                             }
                         }
                     }

logic/Preparation/Interface/IOccupation.cs

@@ -45,10 +45,10 @@ namespace Preparation.Interface
         public double concealment = GameData.basicConcealment * 1.5;
         public double Concealment => concealment;
 
-        public int alertnessRadius = (int)(GameData.basicAlertnessRadius * 1.3);
+        public int alertnessRadius = (int)(GameData.basicGhostAlertnessRadius * 1.3);
         public int AlertnessRadius => alertnessRadius;
 
-        public int viewRange = (int)(GameData.basicViewRange * 1.3);
+        public int viewRange = (int)(GameData.basicGhostViewRange * 1.2);
         public int ViewRange => viewRange;
 
         public int speedOfOpeningOrLocking = GameData.basicSpeedOfOpeningOrLocking;
@@ -62,7 +62,7 @@ namespace Preparation.Interface
     }
     public class Klee : IGhostType
     {
-        private const int moveSpeed = (int)(GameData.basicGhostMoveSpeed * 155 / 127);
+        private const int moveSpeed = GameData.basicGhostMoveSpeed;
         public int MoveSpeed => moveSpeed;
 
         private const int maxHp = GameData.basicHp;
@@ -76,16 +76,16 @@ namespace Preparation.Interface
         public double concealment = GameData.basicConcealment;
         public double Concealment => concealment;
 
-        public int alertnessRadius = (int)(GameData.basicAlertnessRadius * 1.069);
+        public int alertnessRadius = GameData.basicGhostAlertnessRadius;
         public int AlertnessRadius => alertnessRadius;
 
-        public int viewRange = (int)(GameData.basicViewRange * 1.1);
+        public int viewRange = GameData.basicGhostViewRange;
         public int ViewRange => viewRange;
 
-        public int speedOfOpeningOrLocking = (int)(GameData.basicSpeedOfOpeningOrLocking / 1.1);
+        public int speedOfOpeningOrLocking = GameData.basicSpeedOfOpeningOrLocking;
         public int SpeedOfOpeningOrLocking => speedOfOpeningOrLocking;
 
-        public int speedOfClimbingThroughWindows = (int)(GameData.basicGhostSpeedOfClimbingThroughWindows / 1.1);
+        public int speedOfClimbingThroughWindows = GameData.basicGhostSpeedOfClimbingThroughWindows;
         public int SpeedOfClimbingThroughWindows => speedOfClimbingThroughWindows;
 
         public int speedOfOpenChest = (int)(GameData.basicSpeedOfOpenChest * 1.1);
@@ -107,10 +107,10 @@ namespace Preparation.Interface
         public double concealment = GameData.basicConcealment * 0.8;
         public double Concealment => concealment;
 
-        public int alertnessRadius = (int)(GameData.basicAlertnessRadius * 0.9);
+        public int alertnessRadius = (int)(GameData.basicGhostAlertnessRadius * 0.9);
         public int AlertnessRadius => alertnessRadius;
 
-        public int viewRange = (int)(GameData.basicViewRange);
+        public int viewRange = (int)(GameData.basicGhostViewRange);
         public int ViewRange => viewRange;
 
         public int speedOfOpeningOrLocking = GameData.basicSpeedOfOpeningOrLocking;
@@ -141,16 +141,16 @@ namespace Preparation.Interface
         public const int fixSpeed = 0;
         public int FixSpeed => fixSpeed;
 
-        public const int treatSpeed = GameData.basicTreatSpeed;
+        public const int treatSpeed = (int)(GameData.basicTreatSpeed * 0.7);
         public int TreatSpeed => treatSpeed;
 
         public const double concealment = GameData.basicConcealment * 0.5;
         public double Concealment => concealment;
 
-        public const int alertnessRadius = GameData.basicAlertnessRadius / 2;
+        public const int alertnessRadius = GameData.basicStudentAlertnessRadius / 2;
         public int AlertnessRadius => alertnessRadius;
 
-        public int viewRange = GameData.basicViewRange * 9 / 10;
+        public int viewRange = GameData.basicStudentViewRange * 9 / 10;
         public int ViewRange => viewRange;
 
         public int speedOfOpeningOrLocking = GameData.basicSpeedOfOpeningOrLocking;
@@ -164,10 +164,10 @@ namespace Preparation.Interface
     }
     public class Athlete : IStudentType
     {
-        private const int moveSpeed = GameData.basicStudentMoveSpeed * 40 / 38;
+        private const int moveSpeed = GameData.basicStudentMoveSpeed * 11 / 10;
         public int MoveSpeed => moveSpeed;
 
-        private const int maxHp = GameData.basicHp * 32 / 30;
+        private const int maxHp = GameData.basicHp;
         public int MaxHp => maxHp;
 
         private const int maxGamingAddiction = GameData.basicMaxGamingAddiction * 9 / 10;
@@ -187,13 +187,13 @@ namespace Preparation.Interface
         public const double concealment = GameData.basicConcealment * 0.9;
         public double Concealment => concealment;
 
-        public const int alertnessRadius = (int)(GameData.basicAlertnessRadius * 0.9);
+        public const int alertnessRadius = GameData.basicStudentAlertnessRadius;
         public int AlertnessRadius => alertnessRadius;
 
-        public int viewRange = (int)(GameData.basicViewRange * 1.1);
+        public int viewRange = (int)(GameData.basicStudentViewRange * 1.1);
         public int ViewRange => viewRange;
 
-        public int speedOfOpeningOrLocking = GameData.basicSpeedOfOpeningOrLocking * 12 / 10;
+        public int speedOfOpeningOrLocking = GameData.basicSpeedOfOpeningOrLocking;
         public int SpeedOfOpeningOrLocking => speedOfOpeningOrLocking;
 
         public int speedOfClimbingThroughWindows = GameData.basicStudentSpeedOfClimbingThroughWindows * 12 / 10;
@@ -210,7 +210,7 @@ namespace Preparation.Interface
         private const int maxHp = (int)(GameData.basicHp * 1.1);
         public int MaxHp => maxHp;
 
-        private const int maxGamingAddiction = (int)(GameData.basicMaxGamingAddiction * 1.5);
+        private const int maxGamingAddiction = (int)(GameData.basicMaxGamingAddiction * 1.3);
         public int MaxGamingAddiction => maxGamingAddiction;
 
         public BulletType InitBullet => BulletType.Null;
@@ -227,10 +227,10 @@ namespace Preparation.Interface
         public const double concealment = GameData.basicConcealment * 0.9;
         public double Concealment => concealment;
 
-        public const int alertnessRadius = (int)(GameData.basicAlertnessRadius * 0.9);
+        public const int alertnessRadius = (int)(GameData.basicStudentAlertnessRadius * 0.9);
         public int AlertnessRadius => alertnessRadius;
 
-        public int viewRange = (int)(GameData.basicViewRange * 0.9);
+        public int viewRange = (int)(GameData.basicStudentViewRange * 0.9);
         public int ViewRange => viewRange;
 
         public int speedOfOpeningOrLocking = GameData.basicSpeedOfOpeningOrLocking;
@@ -267,10 +267,10 @@ namespace Preparation.Interface
         public const double concealment = GameData.basicConcealment;
         public double Concealment => concealment;
 
-        public const int alertnessRadius = (int)(GameData.basicAlertnessRadius);
+        public const int alertnessRadius = (int)(GameData.basicStudentAlertnessRadius);
         public int AlertnessRadius => alertnessRadius;
 
-        public int viewRange = GameData.basicViewRange;
+        public int viewRange = GameData.basicStudentViewRange;
         public int ViewRange => viewRange;
 
         public int speedOfOpeningOrLocking = GameData.basicSpeedOfOpeningOrLocking;
@@ -307,10 +307,10 @@ namespace Preparation.Interface
         public const double concealment = GameData.basicConcealment;
         public double Concealment => concealment;
 
-        public const int alertnessRadius = (int)(GameData.basicAlertnessRadius);
+        public const int alertnessRadius = (int)(GameData.basicStudentAlertnessRadius);
         public int AlertnessRadius => alertnessRadius;
 
-        public int viewRange = (int)(GameData.basicViewRange * 0.9);
+        public int viewRange = (int)(GameData.basicStudentViewRange * 0.9);
         public int ViewRange => viewRange;
 
         public int speedOfOpeningOrLocking = GameData.basicSpeedOfOpeningOrLocking;
@@ -338,19 +338,19 @@ namespace Preparation.Interface
         public List<ActiveSkillType> ListOfIActiveSkill => new(new ActiveSkillType[] { ActiveSkillType.Rouse, ActiveSkillType.Encourage, ActiveSkillType.Inspire });
         public List<PassiveSkillType> ListOfIPassiveSkill => new(new PassiveSkillType[] { });
 
-        public const int fixSpeed = GameData.basicFixSpeed * 11 / 10;
+        public const int fixSpeed = GameData.basicFixSpeed;
         public int FixSpeed => fixSpeed;
 
         public const int treatSpeed = GameData.basicTreatSpeed * 2;
         public int TreatSpeed => treatSpeed;
 
-        public const double concealment = GameData.basicConcealment * 1.2;
+        public const double concealment = GameData.basicConcealment;
         public double Concealment => concealment;
 
-        public const int alertnessRadius = (int)(GameData.basicAlertnessRadius * 1.2);
+        public const int alertnessRadius = GameData.basicStudentAlertnessRadius;
         public int AlertnessRadius => alertnessRadius;
 
-        public int viewRange = (int)(GameData.basicViewRange * 1.1);
+        public int viewRange = GameData.basicStudentViewRange;
         public int ViewRange => viewRange;
 
         public int speedOfOpeningOrLocking = GameData.basicSpeedOfOpeningOrLocking;

logic/Preparation/Interface/ISkill.cs

@@ -16,286 +16,286 @@ namespace Preparation.Interface
         public object ActiveSkillLock { get; }
         public bool IsBeingUsed { get; set; }
     }
-}
-public class CanBeginToCharge : IActiveSkill
-{
-    public int SkillCD => GameData.commonSkillCD * 24 / 30;
-    public int DurationTime => GameData.commonSkillTime * 5 / 10;
+    public class CanBeginToCharge : IActiveSkill
+    {
+        public int SkillCD => GameData.commonSkillCD * 24 / 30;
+        public int DurationTime => GameData.commonSkillTime * 5 / 10;
 
-    private readonly object commonSkillLock = new object();
-    public object ActiveSkillLock => commonSkillLock;
+        private readonly object commonSkillLock = new object();
+        public object ActiveSkillLock => commonSkillLock;
 
-    public bool isBeingUsed = false;
-    public bool IsBeingUsed
-    {
-        get => isBeingUsed; set => isBeingUsed = value;
+        public bool isBeingUsed = false;
+        public bool IsBeingUsed
+        {
+            get => isBeingUsed; set => isBeingUsed = value;
+        }
     }
-}
 
-public class BecomeInvisible : IActiveSkill
-{
-    public int SkillCD => GameData.commonSkillCD;
-    public int DurationTime => GameData.commonSkillTime * 6 / 10;
+    public class BecomeInvisible : IActiveSkill
+    {
+        public int SkillCD => GameData.commonSkillCD;
+        public int DurationTime => GameData.commonSkillTime * 6 / 10;
 
-    private readonly object commonSkillLock = new object();
-    public object ActiveSkillLock => commonSkillLock;
+        private readonly object commonSkillLock = new object();
+        public object ActiveSkillLock => commonSkillLock;
 
-    public bool isBeingUsed = false;
-    public bool IsBeingUsed
-    {
-        get => isBeingUsed; set => isBeingUsed = value;
+        public bool isBeingUsed = false;
+        public bool IsBeingUsed
+        {
+            get => isBeingUsed; set => isBeingUsed = value;
+        }
     }
-}
 
-public class Punish : IActiveSkill
-{
-    public int SkillCD => GameData.commonSkillCD;
-    public int DurationTime => 0;
+    public class Punish : IActiveSkill
+    {
+        public int SkillCD => GameData.commonSkillCD;
+        public int DurationTime => 0;
 
-    private readonly object commonSkillLock = new object();
-    public object ActiveSkillLock => commonSkillLock;
+        private readonly object commonSkillLock = new object();
+        public object ActiveSkillLock => commonSkillLock;
 
-    public bool isBeingUsed = false;
-    public bool IsBeingUsed
-    {
-        get => isBeingUsed; set => isBeingUsed = value;
+        public bool isBeingUsed = false;
+        public bool IsBeingUsed
+        {
+            get => isBeingUsed; set => isBeingUsed = value;
+        }
     }
-}
 
-public class Rouse : IActiveSkill
-{
-    public int SkillCD => GameData.commonSkillCD * 2;
-    public int DurationTime => 0;
+    public class Rouse : IActiveSkill
+    {
+        public int SkillCD => GameData.commonSkillCD * 2;
+        public int DurationTime => 0;
 
-    private readonly object commonSkillLock = new object();
-    public object ActiveSkillLock => commonSkillLock;
+        private readonly object commonSkillLock = new object();
+        public object ActiveSkillLock => commonSkillLock;
 
-    public bool isBeingUsed = false;
-    public bool IsBeingUsed
-    {
-        get => isBeingUsed; set => isBeingUsed = value;
+        public bool isBeingUsed = false;
+        public bool IsBeingUsed
+        {
+            get => isBeingUsed; set => isBeingUsed = value;
+        }
     }
-}
 
-public class Encourage : IActiveSkill
-{
-    public int SkillCD => GameData.commonSkillCD * 2;
-    public int DurationTime => 0;
+    public class Encourage : IActiveSkill
+    {
+        public int SkillCD => GameData.commonSkillCD * 2;
+        public int DurationTime => 0;
 
-    private readonly object commonSkillLock = new object();
-    public object ActiveSkillLock => commonSkillLock;
+        private readonly object commonSkillLock = new object();
+        public object ActiveSkillLock => commonSkillLock;
 
-    public bool isBeingUsed = false;
-    public bool IsBeingUsed
-    {
-        get => isBeingUsed; set => isBeingUsed = value;
+        public bool isBeingUsed = false;
+        public bool IsBeingUsed
+        {
+            get => isBeingUsed; set => isBeingUsed = value;
+        }
     }
-}
 
-public class Inspire : IActiveSkill
-{
-    public int SkillCD => GameData.commonSkillCD * 2;
-    public int DurationTime => 0;
+    public class Inspire : IActiveSkill
+    {
+        public int SkillCD => GameData.commonSkillCD * 2;
+        public int DurationTime => 0;
 
-    private readonly object commonSkillLock = new object();
-    public object ActiveSkillLock => commonSkillLock;
+        private readonly object commonSkillLock = new object();
+        public object ActiveSkillLock => commonSkillLock;
 
-    public bool isBeingUsed = false;
-    public bool IsBeingUsed
-    {
-        get => isBeingUsed; set => isBeingUsed = value;
+        public bool isBeingUsed = false;
+        public bool IsBeingUsed
+        {
+            get => isBeingUsed; set => isBeingUsed = value;
+        }
     }
-}
 
-public class Howl : IActiveSkill
-{
-    public int SkillCD => GameData.commonSkillCD * 3 / 4;
-    public int DurationTime => 0;
+    public class Howl : IActiveSkill
+    {
+        public int SkillCD => GameData.commonSkillCD * 25 / 30;
+        public int DurationTime => 0;
 
-    private readonly object commonSkillLock = new object();
-    public object ActiveSkillLock => commonSkillLock;
+        private readonly object commonSkillLock = new object();
+        public object ActiveSkillLock => commonSkillLock;
 
-    public bool isBeingUsed = false;
-    public bool IsBeingUsed
-    {
-        get => isBeingUsed; set => isBeingUsed = value;
+        public bool isBeingUsed = false;
+        public bool IsBeingUsed
+        {
+            get => isBeingUsed; set => isBeingUsed = value;
+        }
     }
-}
-
-public class JumpyBomb : IActiveSkill
-{
-    public int SkillCD => GameData.commonSkillCD / 2;
-    public int DurationTime => GameData.commonSkillTime * 3 / 10;
-    private readonly object commonSkillLock = new object();
-    public object ActiveSkillLock => commonSkillLock;
 
-    public bool isBeingUsed = false;
-    public bool IsBeingUsed
+    public class JumpyBomb : IActiveSkill
     {
-        get => isBeingUsed; set => isBeingUsed = value;
-    }
-}
+        public int SkillCD => GameData.commonSkillCD / 2;
+        public int DurationTime => GameData.commonSkillTime * 3 / 10;
+        private readonly object commonSkillLock = new object();
+        public object ActiveSkillLock => commonSkillLock;
 
-public class UseKnife : IActiveSkill
-{
-    public int SkillCD => GameData.commonSkillCD * 2 / 3;
-    public int DurationTime => GameData.commonSkillTime / 10;
-    private readonly object commonSkillLock = new object();
-    public object ActiveSkillLock => commonSkillLock;
+        public bool isBeingUsed = false;
+        public bool IsBeingUsed
+        {
+            get => isBeingUsed; set => isBeingUsed = value;
+        }
+    }
 
-    public bool isBeingUsed = false;
-    public bool IsBeingUsed
+    public class UseKnife : IActiveSkill
     {
-        get => isBeingUsed; set => isBeingUsed = value;
-    }
-}
+        public int SkillCD => GameData.commonSkillCD * 2 / 3;
+        public int DurationTime => GameData.commonSkillTime / 10;
+        private readonly object commonSkillLock = new object();
+        public object ActiveSkillLock => commonSkillLock;
 
-public class UseRobot : IActiveSkill
-{
-    public int SkillCD => GameData.frameDuration;
-    public int DurationTime => 0;
-    private readonly object commonSkillLock = new object();
-    public object ActiveSkillLock => commonSkillLock;
+        public bool isBeingUsed = false;
+        public bool IsBeingUsed
+        {
+            get => isBeingUsed; set => isBeingUsed = value;
+        }
+    }
 
-    public bool isBeingUsed = false;
-    public bool IsBeingUsed
+    public class UseRobot : IActiveSkill
     {
-        get => isBeingUsed; set => isBeingUsed = value;
-    }
-}
+        public int SkillCD => GameData.frameDuration;
+        public int DurationTime => 0;
+        private readonly object commonSkillLock = new object();
+        public object ActiveSkillLock => commonSkillLock;
 
-public class WriteAnswers : IActiveSkill
-{
-    public int SkillCD => GameData.commonSkillCD;
-    public int DurationTime => 0;
-    private readonly object commonSkillLock = new object();
-    public object ActiveSkillLock => commonSkillLock;
+        public bool isBeingUsed = false;
+        public bool IsBeingUsed
+        {
+            get => isBeingUsed; set => isBeingUsed = value;
+        }
+    }
 
-    private int degreeOfMeditation = 0;
-    public int DegreeOfMeditation
+    public class WriteAnswers : IActiveSkill
     {
-        get => degreeOfMeditation;
-        set
+        public int SkillCD => GameData.commonSkillCD;
+        public int DurationTime => 0;
+        private readonly object commonSkillLock = new object();
+        public object ActiveSkillLock => commonSkillLock;
+
+        private int degreeOfMeditation = 0;
+        public int DegreeOfMeditation
         {
-            lock (commonSkillLock)
+            get => degreeOfMeditation;
+            set
             {
-                degreeOfMeditation = value;
+                lock (commonSkillLock)
+                {
+                    degreeOfMeditation = value;
+                }
             }
         }
+        public bool isBeingUsed = false;
+        public bool IsBeingUsed
+        {
+            get => isBeingUsed; set => isBeingUsed = value;
+        }
     }
-    public bool isBeingUsed = false;
-    public bool IsBeingUsed
-    {
-        get => isBeingUsed; set => isBeingUsed = value;
-    }
-}
 
-public class SummonGolem : IActiveSkill
-{
-    public int SkillCD => GameData.commonSkillCD;
-    public int DurationTime => 0;
-    private readonly object commonSkillLock = new object();
-    public object ActiveSkillLock => commonSkillLock;
-
-    private IGolem? golemSummoned = null;
-    public IGolem? GolemSummoned
+    public class SummonGolem : IActiveSkill
     {
-        get => golemSummoned;
-        set
+        public int SkillCD => GameData.commonSkillCD;
+        public int DurationTime => 0;
+        private readonly object commonSkillLock = new object();
+        public object ActiveSkillLock => commonSkillLock;
+
+        private IGolem? golemSummoned = null;
+        public IGolem? GolemSummoned
         {
-            lock (commonSkillLock)
+            get => golemSummoned;
+            set
             {
-                golemSummoned = value;
+                lock (commonSkillLock)
+                {
+                    golemSummoned = value;
+                }
             }
         }
-    }
 
-    public bool isBeingUsed = false;
-    public bool IsBeingUsed
-    {
-        get => isBeingUsed; set => isBeingUsed = value;
+        public bool isBeingUsed = false;
+        public bool IsBeingUsed
+        {
+            get => isBeingUsed; set => isBeingUsed = value;
+        }
     }
-}
 
-public class NullSkill : IActiveSkill
-{
-    public int SkillCD => GameData.commonSkillCD;
-    public int DurationTime => GameData.commonSkillTime;
-    private readonly object commonSkillLock = new object();
-    public object ActiveSkillLock => commonSkillLock;
-
-    public bool isBeingUsed = false;
-    public bool IsBeingUsed
+    public class NullSkill : IActiveSkill
     {
-        get => isBeingUsed; set => isBeingUsed = false;
-    }
-}
+        public int SkillCD => GameData.commonSkillCD;
+        public int DurationTime => GameData.commonSkillTime;
+        private readonly object commonSkillLock = new object();
+        public object ActiveSkillLock => commonSkillLock;
 
-public static class SkillFactory
-{
-    public static IActiveSkill FindIActiveSkill(ActiveSkillType activeSkillType)
-    {
-        switch (activeSkillType)
+        public bool isBeingUsed = false;
+        public bool IsBeingUsed
         {
-            case ActiveSkillType.BecomeInvisible:
-                return new BecomeInvisible();
-            case ActiveSkillType.UseKnife:
-                return new UseKnife();
-            case ActiveSkillType.Howl:
-                return new Howl();
-            case ActiveSkillType.Encourage:
-                return new Encourage();
-            case ActiveSkillType.CanBeginToCharge:
-                return new CanBeginToCharge();
-            case ActiveSkillType.Punish:
-                return new Punish();
-            case ActiveSkillType.JumpyBomb:
-                return new JumpyBomb();
-            case ActiveSkillType.WriteAnswers:
-                return new WriteAnswers();
-            case ActiveSkillType.SummonGolem:
-                return new SummonGolem();
-            case ActiveSkillType.UseRobot:
-                return new UseRobot();
-            case ActiveSkillType.Rouse:
-                return new Rouse();
-            case ActiveSkillType.Inspire:
-                return new Inspire();
-            default:
-                return new NullSkill();
+            get => isBeingUsed; set => isBeingUsed = false;
         }
     }
 
-    public static ActiveSkillType FindActiveSkillType(IActiveSkill ActiveSkill)
+    public static class SkillFactory
     {
-        switch (ActiveSkill)
+        public static IActiveSkill FindIActiveSkill(ActiveSkillType activeSkillType)
         {
-            case BecomeInvisible:
-                return ActiveSkillType.BecomeInvisible;
-            case Howl:
-                return ActiveSkillType.Howl;
-            case UseKnife:
-                return ActiveSkillType.UseKnife;
-            case Encourage:
-                return ActiveSkillType.Encourage;
-            case CanBeginToCharge:
-                return ActiveSkillType.CanBeginToCharge;
-            case Inspire:
-                return ActiveSkillType.Inspire;
-            case Punish:
-                return ActiveSkillType.Punish;
-            case JumpyBomb:
-                return ActiveSkillType.JumpyBomb;
-            case WriteAnswers:
-                return ActiveSkillType.WriteAnswers;
-            case SummonGolem:
-                return ActiveSkillType.SummonGolem;
-            case UseRobot:
-                return ActiveSkillType.UseRobot;
-            case Rouse:
-                return ActiveSkillType.Rouse;
-            default:
-                return ActiveSkillType.Null;
+            switch (activeSkillType)
+            {
+                case ActiveSkillType.BecomeInvisible:
+                    return new BecomeInvisible();
+                case ActiveSkillType.UseKnife:
+                    return new UseKnife();
+                case ActiveSkillType.Howl:
+                    return new Howl();
+                case ActiveSkillType.Encourage:
+                    return new Encourage();
+                case ActiveSkillType.CanBeginToCharge:
+                    return new CanBeginToCharge();
+                case ActiveSkillType.Punish:
+                    return new Punish();
+                case ActiveSkillType.JumpyBomb:
+                    return new JumpyBomb();
+                case ActiveSkillType.WriteAnswers:
+                    return new WriteAnswers();
+                case ActiveSkillType.SummonGolem:
+                    return new SummonGolem();
+                case ActiveSkillType.UseRobot:
+                    return new UseRobot();
+                case ActiveSkillType.Rouse:
+                    return new Rouse();
+                case ActiveSkillType.Inspire:
+                    return new Inspire();
+                default:
+                    return new NullSkill();
+            }
+        }
+
+        public static ActiveSkillType FindActiveSkillType(IActiveSkill ActiveSkill)
+        {
+            switch (ActiveSkill)
+            {
+                case BecomeInvisible:
+                    return ActiveSkillType.BecomeInvisible;
+                case Howl:
+                    return ActiveSkillType.Howl;
+                case UseKnife:
+                    return ActiveSkillType.UseKnife;
+                case Encourage:
+                    return ActiveSkillType.Encourage;
+                case CanBeginToCharge:
+                    return ActiveSkillType.CanBeginToCharge;
+                case Inspire:
+                    return ActiveSkillType.Inspire;
+                case Punish:
+                    return ActiveSkillType.Punish;
+                case JumpyBomb:
+                    return ActiveSkillType.JumpyBomb;
+                case WriteAnswers:
+                    return ActiveSkillType.WriteAnswers;
+                case SummonGolem:
+                    return ActiveSkillType.SummonGolem;
+                case UseRobot:
+                    return ActiveSkillType.UseRobot;
+                case Rouse:
+                    return ActiveSkillType.Rouse;
+                default:
+                    return ActiveSkillType.Null;
+            }
         }
     }
 }

logic/Preparation/Utility/GameData.cs

@@ -87,7 +87,7 @@ namespace Preparation.Utility
         public const int basicSpeedOfOpeningOrLocking = 40;
         public const int basicStudentSpeedOfClimbingThroughWindows = 611;
         public const int basicGhostSpeedOfClimbingThroughWindows = 1270;
-        public const int basicSpeedOfOpenChest = 1000;
+        public const int basicSpeedOfOpenChest = 100;
 
         public const int basicHp = 3000000;                             // 初始血量
         public const int basicMaxGamingAddiction = 60000;//基本完全沉迷时间
@@ -106,8 +106,10 @@ namespace Preparation.Utility
         public const int characterMaxSpeed = 12000;                  // 最大速度
 
         public const double basicConcealment = 1.0;
-        public const int basicAlertnessRadius = 10700;
-        public const int basicViewRange = 5 * numOfPosGridPerCell;
+        public const int basicStudentAlertnessRadius = 15 * numOfPosGridPerCell;
+        public const int basicGhostAlertnessRadius = 17 * numOfPosGridPerCell;
+        public const int basicStudentViewRange = 10 * numOfPosGridPerCell;
+        public const int basicGhostViewRange = 15 * numOfPosGridPerCell;
         public const int maxNumOfPropInPropInventory = 3;
 
         public static XY PosWhoDie = new XY(1, 1);
@@ -168,6 +170,9 @@ namespace Preparation.Utility
         public const int ScorePropClairaudience = 10;
         public const int ScorePropAddHp = 20;
         public const int ScorePropRecoverFromDizziness = 20;
+
+        public const int ScoreBecomeInvisible = 10;
+        public const int ScoreInspire = ScorePropAddSpeed;
         #endregion
         #region 攻击与子弹相关
         public const int basicApOfGhost = 1500000;                             // 捣蛋鬼攻击力
@@ -204,6 +209,9 @@ namespace Preparation.Utility
 
         public const int TimeOfStunnedWhenJumpyDumpty = 3070;
 
+        public const double AddedTimeOfSpeedWhenInspire = 0.6;
+        public const int TimeOfAddingSpeedWhenInspire = 6000;
+
         #endregion
         #region 道具相关
         public const int PropRadius = numOfPosGridPerCell / 2;
@@ -222,9 +230,9 @@ namespace Preparation.Utility
         public const int numOfTeachingBuilding = 3;
         #endregion
         #region 物体相关
-        public const int degreeOfFixedGenerator = 10300000;
+        public const int degreeOfFixedGenerator = 8180000;
         public const int degreeOfLockingOrOpeningTheDoor = 100000;
-        public const int degreeOfOpenedChest = 10000;
+        public const int degreeOfOpenedChest = 100000;
         public const int degreeOfOpenedDoorway = 18000;
         public const int maxNumOfPropInChest = 2;
         public const int numOfGeneratorRequiredForRepair = 7;

logic/规则Logic.md

@@ -76,7 +76,7 @@
 - 当求生者血量归零时，求生者自动原地进入沉迷状态，每毫秒增加1沉迷度
 - 该学生可由其他的求生者唤醒，唤醒后，血量恢复至1/2并可以重新行动。沉迷程度不清空。
 - 一般情况下，唤醒时间为1秒。
-- 进入沉迷状态时。如果求生者原本沉迷程度在（0，20900）中，求生者沉迷程度直接变为20900；如果求生者原本沉迷程度在【20900，40300）中，求生者沉迷程度直接变为40300；如果求生者原本沉迷程度大于40300，从游戏中出局；
+- 进入沉迷状态时。如果求生者原本沉迷程度在（0，其最大沉迷度/3）中，求生者沉迷程度直接变为其最大沉迷度/3；如果求生者原本沉迷程度在[其最大沉迷度/3，其最大沉迷度*2/3）中，求生者沉迷程度直接变为其最大沉迷度*2/3；如果求生者原本沉迷程度大于其最大沉迷度*2/3，从游戏中出局；
 - 当求生者沉迷程度达到该玩家最大沉迷程度时，从游戏中出局
 
 #### 门
@@ -138,53 +138,107 @@
 ## 职业与技能
 
 ### 捣蛋鬼
+
+|   捣蛋鬼职业       |   基本量                 |        Assassin            |        Klee        |            喧哗者ANoisyPerson        |
+| :------------ | :--------------------- |  :--------------------- |  :--------------------- | :--------------------- |
+|   移动速度   |  1,503                   |     1.1             |      1                    |   1.07      | 
+|   隐蔽度   |      1.0                 |      1.5              |      1                            |     0.8     | 
+|   警戒范围   |    17000                 |      1.3             |      1                            |   0.9      | 
+|   视野范围   |    15000                 |      1.2             |      1                            |    1   | 
+|   开锁门时间（ms）|  2500               |     1/1              |    1                            |      1     |
+|   翻窗速度   |   1270                 |   1                   |       1       |     1.1       |     
+|   翻箱时间（ms）   |  10000           |           1/1      |   1/1.1         |     1      |
+
 #### 刺客
 - 普通攻击为 CommonAttackOfGhost
 - 主动技能
   - 隐身
-    在DurationTime时间内玩家隐身
+    - CD：30s 持续时间：6s
+    - 在持续时间内玩家隐身
+    - 使用瞬间得分
   - 使用飞刀
-    在DurationTime时间内，攻击类型变为飞刀
+    - CD：20s 持续时间：1s
+    - 在持续时间内，攻击类型变为飞刀
+    - 不得分
 
 #### Klee
-  - 普通攻击为 CommonAttackOfGhost
-  - 主动技能
-    - 蹦蹦炸弹
-    - 在DurationTime内，攻击类型变为蹦蹦炸弹
+- 普通攻击为 CommonAttackOfGhost
+- 主动技能
+  - 蹦蹦炸弹
+    - CD：15s 持续时间：3s
+    - 在持续时间内，攻击类型变为蹦蹦炸弹
     - 当蹦蹦炸弹因为碰撞而爆炸，向子弹方向上加上90°，270° 发出2个小炸弹
-    - 2个小炸弹运动停止前会因为碰撞爆炸，停止运动后学生碰撞会造成眩晕（AP / GameData.timeFactorOfGhostFainting）ms
+    - 2个小炸弹运动停止前会因为碰撞爆炸，停止运动后学生碰撞会造成眩晕3.07s
+    - 不得分
 
 #### 喧哗者
-  - 主动技能
-    - 嚎叫
-    使用瞬间，在视野半径范围内（不是可视区域）的学生被眩晕（GameData.TimeOfStudentFaintingWhenHowl）ms，自己进入（GameData.TimeOfGhostSwingingAfterHowl）ms的后摇
-  - 被动技能
-    在场所有学生Bgm系统被设为无用的值
+- 普通攻击为 CommonAttackOfGhost
+- 主动技能
+  - 嚎叫
+    - CD：25s 
+    - 使用瞬间，在视野半径范围内（不是可视区域）的学生被眩晕6110ms，自己进入3070ms的后摇
+    - 通过眩晕获得对应得分
+- 被动技能
+  - 在场所有学生Bgm系统被设为无用的值
 
 
 ### 学生（&老师）
 
+|   学生职业       |   基本量             |        教师Teacher       |        健身狂Athlete    |      学霸StraightAStudent        |      开心果Sunshine        |
+| :------------ | :--------------------- |  :--------------------- |  :--------------------- | :--------------------- | :--------------------- |
+|   移动速度   |  1,270                   |     3 / 4             |      1.1                    |   0.8      |    1      | 
+|   最大毅力值   |  3000000                   |     10             |      1                    |   1.1      |    32/30      |
+|   最大沉迷度   |  60000                   |     10             |        0.9                    |   1.3      |    1.1      |
+|   学习一科时间（ms）   |  81800             |     1/0             |      10/6                    |   10/11      |   1      | 
+|   治疗速度   |      100                   |     0.7             |      0.8                    |   0.8      |      2      |
+|   隐蔽度   |      1.0                 |      0.5              |      0.9                            |     0.9     |    1      |
+|   警戒范围   |    15000                 |      0.5             |      1                            |   0.9      |    1      |
+|   视野范围   |    10000                 |      0.9             |      1.1                            |    0.9   |    1      |
+|   开锁门时间（ms）|  2500               |     1/1              |    1                            |      1     |   1      |
+|   翻窗速度   |   1270                 |       0.5             |       1.2       |     10/12       |           1     |
+|   翻箱时间（ms）   |  10000           |            1/1          |   1         |     1      |      1     |
+
 #### 运动员
-  - 主动技能 
-    - 冲撞
-    在DurationTime内，速度变为三倍，期间撞到捣蛋鬼，会导致捣蛋鬼眩晕7.22s,学生眩晕2.09s
+- 主动技能 
+  - 冲撞
+    - CD：24s 持续时间：5s
+    - 在持续时间内，速度变为三倍，期间撞到捣蛋鬼，会导致捣蛋鬼眩晕7.22s,学生眩晕2.09s
+    - 通过眩晕获得对应得分
 
 #### 教师
 - 主动技能
   - 惩罚
-  使用瞬间，在可视范围内的使用技能状态中、攻击前后摇的捣蛋鬼会被眩晕（3070）ms，
+    - CD：30s 
+    - 使用瞬间，在可视范围内的使用技能状态中、攻击前后摇的捣蛋鬼会被眩晕（3070）ms，
+    - 通过眩晕获得对应得分
 - 特性
-  教师无法获得牵制得分
+  - 教师无法获得牵制得分
 
 #### 学霸
 - 被动技能
   - 冥想
-    -当玩家处于可接受指令状态且不在修机时，会积累学习进度，速度为（GameData.basicFixSpeed / 4）/ms
-    -受到攻击（并非伤害）或眩晕或翻窗（或攻击他人）学习进度清零
--主动技能
+    - 当玩家处于可接受指令状态且不在修机时，会积累学习进度，速度为（GameData.basicFixSpeed / 4）/ms
+    - 受到攻击（并非伤害）或眩晕或翻窗（或攻击他人）学习进度清零
+- 主动技能
   - 写答案
-    -使用瞬间，对于可互动范围内的一台电机增加这个学习进度
-  
+    - CD：30s
+    - 使用瞬间，对于可互动范围内的一台电机增加这个学习进度
+    - 不得分
+
+#### 开心果
+- 主动技能
+  - 唤醒
+    - CD：60s 
+    - 使用瞬间，唤醒可视范围内一个沉迷中的人
+    - 通过唤醒获得对应得分
+  - 勉励
+    - CD：60s
+    - 使用瞬间，治疗完成可视范围内一个毅力不足中的人
+    - 通过治疗获得对应得分
+  - 鼓舞
+    - CD：60s  
+    - 使用瞬间，可视范围内学生（包括自己）获得持续6秒的1.6倍速Buff
+    - 每鼓舞一个学生得分10
 
 ## 游戏数据
 请自行查看Logic/Preparation/Utility/GameData.cs