注释乱码问题

ActionTowerDefense/Assets/Scripts/Boss/Boss.cs

@@ -7,10 +7,10 @@ using TMPro;
 
 public enum AttackState
 {
-    Idle = 0,       //锟斤拷锟斤拷
-    Attack = 1,     //锟斤拷锟斤拷
-    Die = 2,        //锟斤拷锟斤拷
-    Weak = 3,       //锟斤拷锟斤拷
+    Idle = 0,       //待机
+    Attack = 1,     //攻击
+    Die = 2,        //死亡
+    Weak = 3,       //虚弱
 }
 
 public enum AttackCategories
@@ -22,9 +22,9 @@ public enum AttackCategories
 [System.Serializable]
 public struct BossState
 {
-    public int coreHp;                      //锟斤拷锟斤拷血锟斤拷
-    public float scale;                     //锟斤拷锟斤拷
-    public StateWeakness[] weaknesses;      //锟斤拷锟斤拷
+    public int coreHp;                      //核心血量
+    public float scale;                     //体型
+    public StateWeakness[] weaknesses;      //弱点
     public GameObject core;
 }
 
@@ -37,34 +37,34 @@ public struct StateWeakness
 
 public class Boss : MoveCharacter
 {
-    [Header("Boss锟斤拷锟斤拷")]
-    public BossState[] states;              //锟阶讹拷
-    private int maxStateId;                 //锟斤拷锟轿�拷诩锟斤拷锥危锟�0锟斤拷始
-    public int curStateId;                  //锟斤拷前锟斤拷锟节阶讹拷n
+    [Header("Boss属性")]
+    public BossState[] states;              //阶段
+    private int maxStateId;                 //最高为第几阶段，0开始
+    public int curStateId;                  //当前处于阶段n
     private BossState curState;
-    private int curStateTotalHp;            //锟斤拷前锟阶讹拷锟斤拷血锟斤拷
-    public int restWeaknessNum;             //剩锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+    private int curStateTotalHp;            //当前阶段总血量
+    public int restWeaknessNum;             //剩余弱点数量
     private Weakness coreWeakness;
     public GameObject roarEffect;
     public float roarTime;
     public bool isChangeState;
 
-    [Header("锟斤拷锟斤拷锟杰碉拷锟剿猴拷锟斤拷锟斤拷")]
+    [Header("核心受到伤害倍率")]
     public int coreDamageRate;
 
-    [Header("锟斤拷前锟斤拷锟斤拷锟角讹拷锟斤拷锟斤拷锟角讹拷锟斤拷锟�")]
+    [Header("当前索敌是对塔还是对玩家")]
     public TargetType curTarget;
 
-    [Header("Boss锟斤拷锟斤拷锟斤拷锟斤拷")]
-    public string circulate;                //循锟斤拷锟斤拷锟斤拷
+    [Header("Boss攻击规律")]
+    public string circulate;                //循环配置
     private int len;
-    public AttackCategories[] categories;  //循锟斤拷锟斤拷锟斤拷
-    private AttackCategories curCategory;   //锟斤拷前锟斤拷锟斤拷锟斤拷锟斤拷
+    public AttackCategories[] categories;  //循环大类
+    private AttackCategories curCategory;   //当前攻击大类
     public int curCategoryID;
-    public float minInterval, maxInterval;  //锟斤拷锟绞憋拷锟�
+    public float minInterval, maxInterval;  //间隔时间
     private float curInterval;
 
-    //锟斤拷锟姐当前锟斤拷态锟斤拷血锟斤拷
+    //计算当前形态总血量
     private void CalculateHp()
     {
         curStateTotalHp = curState.coreHp * coreDamageRate;
@@ -77,7 +77,7 @@ public class Boss : MoveCharacter
         uiHp.Show(hp, totalHp);
     }
 
-    //锟叫伙拷锟斤拷态
+    //切换形态
     private void ChangeBossState()
     {
         curState = states[curStateId];
@@ -88,7 +88,7 @@ public class Boss : MoveCharacter
         curInterval = Random.Range(minInterval, maxInterval);
     }
 
-    //锟叫伙拷锟斤拷锟斤拷
+    //切换弱点
     private void ChangeWeakness()
     {
         StateWeakness[] ws = curState.weaknesses;
@@ -105,13 +105,13 @@ public class Boss : MoveCharacter
 
     public override void Init()
     {
-        //确锟斤拷锟斤拷锟斤拷锟斤拷锟绞�
+        //确保组件不丢失
         if (!ani)
         {
             ani = GetComponentInChildren<Animator>();
         }
 
-        //血锟斤拷锟斤拷锟斤拷
+        //血量重置
         hp = totalHp;
         uiHp.Show(hp, totalHp);
         ChangeState(CharacterState.Idle);
@@ -156,7 +156,7 @@ public class Boss : MoveCharacter
         }
         hp -= damage;
 
-        //锟剿猴拷锟斤拷锟斤拷
+        //伤害跳字
         if (showInjuryNum)
         {
             GameObject injuryNum = Instantiate(injuryNumText);
@@ -361,7 +361,7 @@ public class Boss : MoveCharacter
 
     public void EndCurAttackState(bool hasIntervalTime)
     {
-        //锟斤拷锟斤拷一锟斤拷锟斤拷锟斤拷锟斤拷没锟叫硷拷锟�
+        //和下一个动作有没有间隔
         if (hasIntervalTime)
         {
             curInterval = Random.Range(minInterval, maxInterval);

ActionTowerDefense/Assets/Scripts/Boss/YuMenGuan/Block.cs

@@ -7,60 +7,60 @@ public class Block : Character
 {
     public enum State
     {
-        outGround = 0,      //锟斤拷锟斤拷
-        charge = 1,         //锟斤拷锟斤拷
-        sprint = 2,         //锟斤拷锟�
-        bomb = 3,           //锟斤拷炸
+        outGround = 0,      //出土
+        charge = 1,         //蓄力
+        sprint = 2,         //冲刺
+        bomb = 3,           //爆炸
         none = 4,
-        back = 5,           //锟斤拷锟斤拷锟缴猴拷锟斤拷
-        warning = 6,        //预锟斤拷
-        drop = 7,           //坠锟斤拷
+        back = 5,           //被击飞后退
+        warning = 6,        //预警
+        drop = 7,           //坠落
     }
 
-    [Header("锟斤拷锟斤拷")]
+    [Header("属性")]
     public YuMenGuan ymg;
     public bool isSpecial;
     public bool isSpecialDie;
 
-    [Header("锟斤拷锟斤拷锟�")]
+    [Header("掉落魂")]
     public GameObject soulPrefab;
     public float soulStartSpeed = 1f;
     public int dropSoul;
     public float dropSoulAngle = 60f;
 
-    [Header("砖头锟街癸拷锟斤拷状态")]
+    [Header("砖头怪攻击状态")]
     public State curState;
-    public float chargeTime;            //锟斤拷锟斤拷锟斤拷锟斤拷时锟斤拷
+    public float chargeTime;            //空中蓄力时长
     private float hasChargeTime;
 
-    [Header("锟斤拷锟斤拷锟斤拷锟�")]
+    [Header("冲出地面")]
     public float outSpeed;
-    public float maxHeight, minHeight;  //锟芥即锟竭讹拷
+    public float maxHeight, minHeight;  //随即高度
     public float height;
     public AttackInfo outDamage;
 
-    [Header("锟斤拷前锟斤拷锟�")]
-    public float sprintAccSpeed;        //锟斤拷碳锟斤拷俣锟�
-    private float curSpeed;                //锟斤拷前锟劫讹拷
+    [Header("向前冲刺")]
+    public float sprintAccSpeed;        //冲刺加速度
+    private float curSpeed;                //当前速度
 
-    [Header("锟斤拷锟斤拷")]
+    [Header("警告")]
     public GameObject warning;
     public Vector3 posYZ;
     private GameObject curWarning;
     public float warningTime;
     private float hasWarningTime;
 
-    [Header("锟斤拷炸")]
+    [Header("爆炸")]
     public GameObject bombPrefab;
     private bool isTowerBomb;
     private GameObject curBomb;
 
-    [Header("锟斤拷锟斤拷锟斤拷源")]
+    [Header("攻击来源")]
     public BeHitTrigger hitTrigger;
     public int attackerID;
 
-    [Header("锟斤拷锟缴轨迹")]
-    public float backForceRate;     //锟斤拷锟缴碉拷锟斤拷锟侥憋拷锟斤拷
+    [Header("击飞轨迹")]
+    public float backForceRate;     //击飞的力的倍数
 
     public void Ready()
     {
@@ -175,7 +175,7 @@ public class Block : Character
         {
             hp -= damage;
 
-            //锟剿猴拷锟斤拷锟斤拷
+            //伤害跳字
             if (showInjuryNum)
             {
                 GameObject injuryNum = Instantiate(injuryNumText);

ActionTowerDefense/Assets/Scripts/Boss/YuMenGuan/YuMenGuan.cs

@@ -7,12 +7,12 @@ public class YuMenGuan : Boss
     public enum AttackMethods
     {
         none = 0,
-        move = 1,           //锟狡讹拷
-        shockWave1 = 2,     //锟斤拷锟斤拷锟揭地ｏ拷锟斤拷锟斤拷锟斤拷锟斤拷
-        shockWave2 = 3,     //双锟斤拷锟揭地ｏ拷锟斤拷锟斤拷锟斤拷锟斤拷*3
-        laser = 4,          //锟桔撅拷锟斤拷锟斤拷
-        block = 5,          //砖头锟斤拷
-        blackHand = 6,      //锟斤拷锟斤拷
+        move = 1,           //移动
+        shockWave1 = 2,     //单手砸地，两侧冲击波
+        shockWave2 = 3,     //双手砸地，两侧冲击波*3
+        laser = 4,          //眼睛激光
+        block = 5,          //砖头怪
+        blackHand = 6,      //黑手
     }
 
     public enum PoolType
@@ -26,7 +26,7 @@ public class YuMenGuan : Boss
     public struct AttackAssignment
     {
         public AttackMethods attack;
-        public int weight;              //权锟斤拷
+        public int weight;              //权重
     }
 
     [System.Serializable]
@@ -36,19 +36,19 @@ public class YuMenGuan : Boss
         public AttackAssignment[] attacks;
     }
 
-    [Header("锟斤拷锟斤拷锟斤拷锟斤拷")]
+    [Header("攻击配置")]
     public BossAttackType[] attackConfigurations;
     private AttackMethods curAttackType;
 
-    [Header("锟狡讹拷")]
+    [Header("移动")]
     public float maxMoveDis, minMoveDis;
     private float curMoveDis;
     private float hasMoveDis;
     private float origMoveX;
-    private bool isAttackWalk;          //锟斤拷为锟斤拷锟斤拷锟斤拷墓锟斤拷锟斤拷锟斤拷贫锟�
+    private bool isAttackWalk;          //作为随机到的攻击而移动
     private Character otherTarget;
 
-    [Header("锟斤拷锟斤拷锟�")]
+    [Header("冲击波")]
     public GameObject wave1;
     public GameObject wave2;
     public AttackInfo wave1Damage;
@@ -59,32 +59,32 @@ public class YuMenGuan : Boss
     public float[] waveEnlargeScale;
     public Vector3 wave1Size;
     public Vector3[] wave2Size;
-    public float[] intervalTime;          //锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟矫匡拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷募锟斤拷时锟斤拷
+    public float[] intervalTime;          //三连冲击波，每个冲击波发射的间隔时间
     private List<Bullet> wave1Pool = new List<Bullet>();
     private List<Bullet> wave2Pool = new List<Bullet>();
-    private int[] hasNum;               //锟斤拷锟斤拷锟斤拷锟叫碉拷锟斤拷锟斤拷
+    private int[] hasNum;               //池中已有的数量
     private List<Bullet> usedWave1 = new List<Bullet>();
     private List<Bullet> usedWave2 = new List<Bullet>();
     private int curWaveIndex = 0;
-    private List<Bullet> transit = new List<Bullet>();  //锟斤拷转
-    private int shockWaveTimes;         //锟斤拷锟斤拷n锟轿碉拷锟街筹拷锟斤拷锟�
-    private bool isContinuous;          //锟斤拷锟斤拷锟斤拷蔚锟斤拷殖锟斤拷锟斤拷
+    private List<Bullet> transit = new List<Bullet>();  //中转
+    private int shockWaveTimes;         //连续n次单手冲击波
+    private bool isContinuous;          //连续多次单手冲击波
     public int maxShockTimes, minShockTimes;
     public float wave1aniTime, wave1loopTime;
     public float wave2aniTime;
     public float waveEndTime;
-    private float waveTime;             //锟斤拷锟斤拷锟斤拷锟斤拷锟绞憋拷锟�
-    private bool isWave1;               //锟斤拷锟斤拷锟�1锟斤拷锟斤拷锟斤拷
-    private bool isWave2;               //锟斤拷锟斤拷锟�2锟斤拷锟斤拷锟斤拷
+    private float waveTime;             //冲击波进行时长
+    private bool isWave1;               //冲击波1进行中
+    private bool isWave2;               //冲击波2进行中
     private bool isEndWave;
 
-    [Header("锟桔撅拷锟斤拷锟斤拷")]
+    [Header("眼睛激光")]
     public EyeLaser laser;
-    public Transform eye;               //锟斤拷锟斤拷锟斤拷锟斤拷锟�
-    public GameObject weakEye;          //锟侥革拷锟斤拷锟姐被锟津爆猴拷锟劫凤拷锟斤拷
-    public float waitTime;              //锟斤拷锟斤拷锟斤拷煤锟绞硷拷锟斤拷浼わ拷锟�
+    public Transform eye;               //从哪里射出
+    public GameObject weakEye;          //哪个弱点被打爆后不再发射
+    public float waitTime;              //蓄力多久后开始发射激光
 
-    [Header("砖头锟斤拷")]
+    [Header("砖头怪")]
     public int minBlocks, maxBlocks;
     public float aniTime;
     private int curBlocks;
@@ -101,7 +101,7 @@ public class YuMenGuan : Boss
         laser.headPos = eye;
     }
 
-    //锟叫断筹拷锟斤拷锟斤拷锟斤拷锟斤拷欠锟斤拷卸锟斤拷锟侥筹拷锟斤拷锟斤拷锟矫伙拷锟斤拷锟绞碉拷锟斤拷锟斤拷碌锟�
+    //判断冲击波池中是否有多余的冲击波，没有则实例化新的
     private void ExpandPool(PoolType id, int num)
     {
         int need = num - hasNum[(int)id];
@@ -154,7 +154,7 @@ public class YuMenGuan : Boss
         }
     }
 
-    //锟狡讹拷锟竭硷拷锟斤拷锟斤拷为锟斤拷锟斤拷锟斤拷锟斤拷贫锟绞憋拷贫锟揭伙拷锟斤拷锟斤拷耄伙拷锟轿�拷锟侥匡拷锟斤拷贫锟绞笔硷拷詹锟阶斤拷欠锟斤拷锌晒锟斤拷锟侥匡拷锟斤拷锟诫范围锟斤拷锟斤拷锟斤拷锟叫筹拷锟狡讹拷状态
+    //移动逻辑，作为随出来的移动时移动一定距离；作为无目标移动时始终捕捉是否有可攻击目标进入范围，有则切出移动状态
     public override void OnMove()
     {
         if (isAttackWalk && (!targetCharacter || targetCharacter.isDie))
@@ -205,7 +205,7 @@ public class YuMenGuan : Boss
         }
     }
 
-    //锟狡讹拷前锟竭硷拷
+    //移动前逻辑
     public override void ToMove()
     {
         ChangeState(CharacterState.Run);
@@ -216,7 +216,7 @@ public class YuMenGuan : Boss
         ani.Play("yumenguan_walk", 0, 0);
     }
 
-    //锟斤拷锟斤拷锟斤拷锟斤拷2锟脚ｏ拷3锟斤拷锟斤拷
+    //发射冲击波2号（3连）
     private void ToLaunchWave2()
     {
         LaunchWave(1, curWaveIndex);
@@ -227,13 +227,13 @@ public class YuMenGuan : Boss
         }
     }
 
-    //锟斤拷锟斤拷锟斤拷锟斤拷1锟斤拷
+    //发射冲击波1号
     private void ToLaunchWave1()
     {
         LaunchWave(0, 0);
     }
 
-    //锟斤拷锟斤拷锟斤拷锟斤拷
+    //发射冲击波
     private void LaunchWave(int id, int index)
     {
         Vector3 dir = Vector3.zero;
@@ -290,7 +290,7 @@ public class YuMenGuan : Boss
         hasNum[id] -= 2;
     }
 
-    //锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+    //连续发射冲击波
     private void ContinueShockWave(int id)
     {
         waveTime += Time.deltaTime;
@@ -335,7 +335,7 @@ public class YuMenGuan : Boss
         }
     }
 
-    //锟斤拷锟斤拷锟斤拷锟斤拷锟�
+    //冲击波攻击
     public void ShockWave(int id)
     {
         switch (id)
@@ -418,7 +418,7 @@ public class YuMenGuan : Boss
         }
     }
 
-    //锟斤拷锟斤拷
+    //攻击
     public override void Attack()
     {
         switch (curAttackType)
@@ -446,7 +446,7 @@ public class YuMenGuan : Boss
         }
     }
 
-    //锟斤拷锟捷碉拷前锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟绞�
+    //根据当前大类随机攻击方式
     public override void RandomAttackType(AttackCategories cate)
     {
         AttackAssignment[] attack = attackConfigurations[(int)cate].attacks;
@@ -486,7 +486,7 @@ public class YuMenGuan : Boss
         }
     }
 
-    //锟斤拷某锟斤拷锟斤拷锟斤拷锟斤按权锟斤拷锟斤拷锟斤拷锟斤拷锟揭伙拷锟斤拷锟斤拷锟斤拷锟斤拷锟�
+    //在某个大类里按权重随机返回一个攻击类型
     public AttackMethods RandomAttack(AttackAssignment[] attackAssigns)
     {
         int weight = 0;

ActionTowerDefense/Assets/Scripts/Demonic.cs

@@ -6,47 +6,47 @@ using UnityEngine;
 
 public class Demonic : MoveCharacter
 {
-    [Header("锟窖凤拷锟斤拷位锟斤拷锟斤拷")]
-    public PlayerController player;      //锟劫伙拷师
+    [Header("友方单位属性")]
+    public PlayerController player;      //召唤师
     public int playerID;
     public int id;
     public float costMp = 10;
     public float totalSummonTime = 0.5f;
     public bool canFly = false;
-    public bool isBack = false;         //锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+    public bool isBack = false;         //往反方向走
     public float flyHeight;
     public float flyUpSpeed = 10;
     public int baseSortingOrder;
     int sortingOrder = 0;
     public float runSpeed;
 
-    [Header("锟斤拷锟斤拷锟斤拷")]
+    [Header("锁魂塔")]
     public bool isReturnSoulTower;
     public Vector3 origSoulPos;
     public bool isRecorded;
 
-    [Header("锟窖凤拷锟斤拷位锟斤拷锟�")]
+    [Header("友方单位组件")]
     public SearchState searchState;
     public Collider soulCollector;
 
-    [Header("锟斤拷锟斤拷")]
+    [Header("攻击")]
     public float attackDistance;
     public float maxAttackDis, minAttackDis;
     public bool needToChange;
 
-    [Header("锟斤拷锟斤拷")]
-    public float adsorbSpeed;                           //锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟劫讹拷
-    [HideInInspector]public Vector3 adsorbTarget;       //锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷时目锟斤拷位锟矫碉拷X
-    private float adsorbTime;                           //锟斤拷锟斤拷锟斤拷锟斤拷锟叫碉拷时锟斤拷
-    public GameObject effectPrefab;                     //锟斤拷锟斤拷锟斤拷锟斤拷效锟斤拷
+    [Header("八卦")]
+    public float adsorbSpeed;                           //八卦吸附的速度
+    [HideInInspector]public Vector3 adsorbTarget;       //八卦胖子吸附时目标位置的X
+    private float adsorbTime;                           //八卦吸附中的时间
+    public GameObject effectPrefab;                     //八卦卦象效果
 
-    [Header("锟斤拷锟斤拷锟�")]
+    [Header("掉落魂")]
     public int dropSoulMax = 3;
     public int dropSoulMin = 1;
     public float dropSoulAngle = 60f;
 
-    [Header("锟斤拷证锟斤拷锟杰匡拷锟斤拷")]
-    public bool upFirstAfterWeaknessOrNot;  //锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟角凤拷锟斤拷锟斤拷锟斤拷
+    [Header("验证功能开关")]
+    public bool upFirstAfterWeaknessOrNot;  //虚弱结束后是否先升高
     private void Awake()
     {
     }
@@ -124,7 +124,7 @@ public class Demonic : MoveCharacter
                     ChangeSearchState(SearchState.InSearchScope);
                     break;
                 }
-                //锟斤拷锟斤拷一锟斤拷锟斤拷贫锟�
+                //向玩家基地移动
                 break;
             case SearchState.InSearchScope:
                 if (!SearchTarget())
@@ -363,11 +363,11 @@ public class Demonic : MoveCharacter
                 }
                 if (leftDir.x > 0.3f)
                 {
-                    //rb.velocity += Vector3.right * moveAcc * Time.deltaTime;
+                    //rb.linearVelocity += Vector3.right * moveAcc * Time.deltaTime;
                     rb.linearVelocity = Vector3.right * (moveSpeed + velocityAddition);
-                    //if (rb.velocity.x > maxMoveSpeed)
+                    //if (rb.linearVelocity.x > maxMoveSpeed)
                     //{
-                    //    rb.velocity = new Vector3(maxMoveSpeed, rb.velocity.y, rb.velocity.z);
+                    //    rb.linearVelocity = new Vector3(maxMoveSpeed, rb.linearVelocity.y, rb.velocity.z);
                     //}
                     if (bodyTrans.localScale.x > 0)
                     {
@@ -376,11 +376,11 @@ public class Demonic : MoveCharacter
                 }
                 else if (leftDir.x < -0.3f)
                 {
-                    //rb.velocity -= Vector3.right * moveAcc * Time.deltaTime;
+                    //rb.linearVelocity -= Vector3.right * moveAcc * Time.deltaTime;
                     rb.linearVelocity = Vector3.right *( -moveSpeed + velocityAddition);
-                    //if (rb.velocity.x < -maxMoveSpeed)
+                    //if (rb.linearVelocity.x < -maxMoveSpeed)
                     //{
-                    //    rb.velocity = new Vector3(-maxMoveSpeed, rb.velocity.y, rb.velocity.z);
+                    //    rb.linearVelocity = new Vector3(-maxMoveSpeed, rb.linearVelocity.y, rb.linearVelocity.z);
                     //}
                     if (bodyTrans.localScale.x < 0)
                     {
@@ -418,11 +418,11 @@ public class Demonic : MoveCharacter
                 }
                 if (leftDir.x > 0.3f)
                 {
-                    //rb.velocity += Vector3.right * moveAcc * Time.deltaTime;
+                    //rb.linearVelocity += Vector3.right * moveAcc * Time.deltaTime;
                     rb.linearVelocity = Vector3.right * runSpeed;
-                    //if (rb.velocity.x > maxMoveSpeed)
+                    //if (rb.linearVelocity.x > maxMoveSpeed)
                     //{
-                    //    rb.velocity = new Vector3(maxMoveSpeed, rb.velocity.y, rb.velocity.z);
+                    //    rb.linearVelocity = new Vector3(maxMoveSpeed, rb.linearVelocity.y, rb.linearVelocity.z);
                     //}
                     if (bodyTrans.localScale.x > 0)
                     {
@@ -431,11 +431,11 @@ public class Demonic : MoveCharacter
                 }
                 else if (leftDir.x < -0.3f)
                 {
-                    //rb.velocity -= Vector3.right * moveAcc * Time.deltaTime;
+                    //rb.linearVelocity -= Vector3.right * moveAcc * Time.deltaTime;
                     rb.linearVelocity = Vector3.left * runSpeed;
-                    //if (rb.velocity.x < -maxMoveSpeed)
+                    //if (rb.linearVelocity.x < -maxMoveSpeed)
                     //{
-                    //    rb.velocity = new Vector3(-maxMoveSpeed, rb.velocity.y, rb.velocity.z);
+                    //    rb.linearVelocity = new Vector3(-maxMoveSpeed, rb.linearVelocity.y, rb.linearVelocity.z);
                     //}
                     if (bodyTrans.localScale.x < 0)
                     {
@@ -452,14 +452,14 @@ public class Demonic : MoveCharacter
                 }
                 //if (btnJumpPress || cacheJumpTime > 0)
                 //{
-                //    if (!airJumped && rb.velocity.y < airJumpSpeed)
+                //    if (!airJumped && rb.linearVelocity.y < airJumpSpeed)
                 //    {
                 //        airJumped = true;
                 //        AirJump();
                 //        break;
                 //    }
                 //}
-                
+
                 rb.linearVelocity += Vector3.up * extraRiseGravity * Time.deltaTime;
                 break;
             case CharacterState.Fall:
@@ -650,7 +650,7 @@ public class Demonic : MoveCharacter
                         targetCharacter = null;
                         FaceToEneTower();
                     }
-                    //锟斤拷锟斤拷锟斤拷锟斤拷使魔锟斤拷锟斤拷原锟截癸拷锟斤拷锟斤拷扫锟借到锟斤拷锟斤拷时锟斤拷停止锟斤拷锟截诧拷锟斤拷锟叫癸拷锟斤拷
+                    //锁魂塔内使魔返回原地过程中扫描到敌人时，停止返回并索敌攻击
                     if (targetCharacter != null && targetCharacter.gameObject.layer == 8 && targetCharacter.isInSoulTower)
                     {
                         ChangeState(CharacterState.Idle);

ActionTowerDefense/Assets/Scripts/Enemy.cs

@@ -20,58 +20,58 @@ public enum TargetType
 
 public enum SearchState
 {
-    NoTarget = 0,       //锟斤拷锟斤拷锟斤拷围锟斤拷没锟斤拷目锟斤拷
-    InSearchScope = 1,  //锟斤拷锟斤拷锟斤拷锟斤拷围锟节凤拷锟斤拷目锟疥，锟斤拷锟斤拷锟节癸拷锟斤拷锟斤拷围锟斤拷
-    InAttackScope = 2,  //目锟斤拷锟节癸拷锟斤拷锟斤拷围锟斤拷
+    NoTarget = 0,       //搜索范围内没有目标
+    InSearchScope = 1,  //在搜索范围内发现目标，但不在攻击范围内
+    InAttackScope = 2,  //目标在攻击范围内
 }
 
 public class Enemy : MoveCharacter
 {
-    [Header("锟叫凤拷锟斤拷位锟斤拷锟斤拷")]
+    [Header("敌方单位属性")]
     public int id;
     public int baseSortingOrder;
     int sortingOrder = 0;
     public bool canFly = false;
-    public bool isBack = false; //锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷
+    public bool isBack = false; //往反方向走
     public float flyHeight;
     public float flyUpSpeed = 10;
     public float jumpSpeed = 10;
     public float maxMoveSpeed, minMoveSpeed;
     public float runSpeed;
 
-    [Header("锟斤拷锟缴★拷锟斤拷幕锟斤拷锟斤拷")]
-    public bool isBeBlownUp;    //锟斤拷锟斤拷锟斤拷
-    public bool isBeReboundedX; //X锟斤拷锟津被凤拷锟斤拷
-    public bool isBeReboundedY; //Y锟斤拷锟津被凤拷锟斤拷
+    [Header("击飞、屏幕反弹")]
+    public bool isBeBlownUp;    //被击飞
+    public bool isBeReboundedX; //X方向被反弹
+    public bool isBeReboundedY; //Y方向被反弹
     private bool hasBeReboundedX;
     private bool hasBeReboundedY;
     public float reboundXSpeed;
     public float reboundYSpeed;
     public int wallDamage;
 
-    [Header("锟斤拷锟窖ｏ拷锟�")]
+    [Header("落地眩晕")]
     public bool willBeComa;
     public float willComaTime;
     public int comaDamage;
 
-    [Header("锟叫凤拷英锟斤拷")]
+    [Header("敌方英灵")]
     public Spirits.SpiritType type;
 
-    [Header("锟叫凤拷锟斤拷位锟斤拷锟�")]
+    [Header("敌方单位组件")]
     public SearchState searchState;
 
-    [Header("锟斤拷锟斤拷")]
+    [Header("攻击")]
     public float attackDistance;
     public float maxAttackDis, minAttackDis;
     public bool needToChange;
     public float attackRatio;
 
-    [Header("锟斤拷锟斤拷锟�")]
+    [Header("掉落魂")]
     public int dropSoulMax = 3;
     public int dropSoulMin = 1;
     public float dropSoulAngle = 60f;
 
-    [Header("锟斤拷坦锟斤拷锟�")]
+    [Header("冲刺攻击")]
     public GameObject aimEffect;
     public DashEffect dashEffect;
 
@@ -97,13 +97,13 @@ public class Enemy : MoveCharacter
 
     [HideInInspector]
     public Vector3 targetDir;
-    public bool haveDownRush;   //锟斤拷探锟斤拷锟斤拷锟斤拷欠锟斤拷锟皆斤拷锟斤拷锟秸�
-    public bool rushHaveAttack; //锟斤拷锟斤拷欠锟斤拷锟剿猴拷
+    public bool haveDownRush;   //冲刺结束后是否可以接落地斩
+    public bool rushHaveAttack; //冲刺是否带伤害
     public float downRushTime;
     public float finishRushTime;
 
-    [Header("锟斤拷证锟斤拷锟杰匡拷锟斤拷")]
-    public bool upFirstAfterWeaknessOrNot;  //锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟角凤拷锟斤拷锟斤拷锟斤拷
+    [Header("验证功能开关")]
+    public bool upFirstAfterWeaknessOrNot;  //虚弱结束后是否先升高
     private void Awake()
     {
         aimDistance = rushTime * rushSpeed / 2;
@@ -304,7 +304,7 @@ public class Enemy : MoveCharacter
                     ChangeState(CharacterState.Run);
                     break;
                 }
-                //rb.velocity = Vector3.zero;
+                //rb.linearVelocity = Vector3.zero;
                 if (!upFirstAfterWeaknessOrNot)
                 {
                     AdjustHeight();
@@ -382,11 +382,11 @@ public class Enemy : MoveCharacter
                 }
                 if (leftDir.x > 0.3f)
                 {
-                    //rb.velocity += Vector3.right * moveAcc * Time.deltaTime;
+                    //rb.linearVelocity += Vector3.right * moveAcc * Time.deltaTime;
                     rb.linearVelocity = Vector3.right * runSpeed;
-                    //if (rb.velocity.x > maxMoveSpeed)
+                    //if (rb.linearVelocity.x > maxMoveSpeed)
                     //{
-                    //    rb.velocity = new Vector3(maxMoveSpeed, rb.velocity.y, rb.velocity.z);
+                    //    rb.linearVelocity = new Vector3(maxMoveSpeed, rb.linearVelocity.y, rb.linearVelocity.z);
                     //}
                     if (bodyTrans.localScale.x > 0)
                     {
@@ -395,11 +395,11 @@ public class Enemy : MoveCharacter
                 }
                 else if (leftDir.x < -0.3f)
                 {
-                    //rb.velocity -= Vector3.right * moveAcc * Time.deltaTime;
+                    //rb.linearVelocity -= Vector3.right * moveAcc * Time.deltaTime;
                     rb.linearVelocity = Vector3.left * runSpeed;
-                    //if (rb.velocity.x < -maxMoveSpeed)
+                    //if (rb.linearVelocity.x < -maxMoveSpeed)
                     //{
-                    //    rb.velocity = new Vector3(-maxMoveSpeed, rb.velocity.y, rb.velocity.z);
+                    //    rb.linearVelocity = new Vector3(-maxMoveSpeed, rb.linearVelocity.y, rb.linearVelocity.z);
                     //}
                     if (bodyTrans.localScale.x < 0)
                     {
@@ -1075,7 +1075,7 @@ public class Enemy : MoveCharacter
                     ChangeSearchState(SearchState.InSearchScope);
                     break;
                 }
-                //锟斤拷锟斤拷一锟斤拷锟斤拷贫锟�
+                //向玩家基地移动
                 break;
             case SearchState.InSearchScope:
                 if (!SearchTarget())

ActionTowerDefense/Assets/Scripts/EnemyTower.cs

@@ -7,8 +7,8 @@ public class EnemyTower : Character
 {
     public float height = 8;
 
-    public bool haveDisappearTime; //锟斤拷锟斤拷失时锟斤拷
-    public float disappearTime;     //锟斤拷失时锟斤拷
+    public bool haveDisappearTime; //有消失时间
+    public float disappearTime;     //消失时间
     private void Awake()
     {
         TowerMap.enemyTowers.Add(gameObject);
@@ -132,7 +132,7 @@ public class EnemyTower : Character
     {
         hp -= damage;
 
-        //锟剿猴拷锟斤拷锟斤拷
+        //伤害跳字
         if (showInjuryNum)
         {
             GameObject injuryNum = Instantiate(injuryNumText);

ActionTowerDefense/Assets/Scripts/Foot.cs

@@ -15,8 +15,8 @@ public class Foot : MonoBehaviour
     }
 
     public List<GameObject> trigGroundList;
-    public BaGuaTrigger myBaGuaTrigger;                                      //锟皆硷拷
-    public List<BaGuaTrigger> baGuaTrigger = new List<BaGuaTrigger>();       //锟斤拷锟铰的帮拷锟斤拷锟斤拷锟斤拷
+    public BaGuaTrigger myBaGuaTrigger;                                      //自己
+    public List<BaGuaTrigger> baGuaTrigger = new List<BaGuaTrigger>();       //脚下的八卦胖子
     public bool notOnGiant;
 
     private void Update()

ActionTowerDefense/Assets/Scripts/PlayerController.cs

@@ -33,22 +33,22 @@ public enum PlayerAttackState
 
 public class PlayerController : MoveCharacter
 {
-    [Header("锟斤拷锟斤拷锟斤拷锟�")]
+    [Header("玩家属性")]
     public int playerId;
     public bool canJump;
     public bool canfly;
-    public bool endTranSummon;  //锟角凤拷锟节斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟劫伙拷英锟斤拷
+    public bool endTranSummon;  //是否在结束变身后召唤英灵
 
-    [Header("锟斤拷锟斤拷英锟斤拷")]
-    public bool isUltimate;     //英锟斤拷锟酵放达拷锟斤拷
-    public bool keyTransfigurateRelease;    //锟缴匡拷英锟斤拷锟酵放达拷锟叫硷拷
+    [Header("变身英灵")]
+    public bool isUltimate;     //英灵释放大招
+    public bool keyTransfigurateRelease;    //松开英灵释放大招键
     public List<GameObject> changePrefabs;
     public int[] needCorpses;
-    private GameObject spiritObj;           //锟斤拷前锟斤拷锟斤拷锟侥讹拷锟斤拷
-    public int endChange = 0;               //锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟劫伙拷锟斤拷英锟斤拷
+    private GameObject spiritObj;           //当前变身的对象
+    public int endChange = 0;               //结束变身后召唤的英灵
     public Vector2 rightDir;
 
-    [Header("锟斤拷锟斤拷锟斤拷")]
+    [Header("玩家组件")]
     public UIHP uiMp;
     public PlayerRope playerRope;
     public EventTrigger eventTrigger;
@@ -59,30 +59,30 @@ public class PlayerController : MoveCharacter
     public SkeletonDataAsset[] playerSpine;
     private SpiritSystem spiritSystem;
 
-    [Header("血锟斤拷")]
+    [Header("血量")]
     private int curHp;
     private int curTotalHp;
 
-    [Header("锟斤拷锟斤拷")]
+    [Header("蓝耗")]
     public float mp;
     public float totalMp;
-    public float totalMp_2Players;      //双锟斤拷模式锟斤拷锟斤拷锟斤拷锟斤拷
+    public float totalMp_2Players;      //双人模式下总蓝量
     public bool isMpRepel = true;
     public bool isRapedReply;
     public float mpReplySpeed;
-    public float mpReplySpeed_2Players; //双锟斤拷模式锟斤拷锟斤拷锟斤拷锟截革拷锟劫讹拷
+    public float mpReplySpeed_2Players; //双人模式下蓝量回复速度
     public float rapidReplySpeed;
     public float lostMp;
     private float addMp = 10;
     public GameObject soul;
     public GameObject rapidReplyEffect;
 
-    [Header("锟狡讹拷锟斤拷锟斤拷")]
-    public Vector2 moveVec;         //锟斤拷也锟斤拷锟绞憋拷贫锟斤拷锟斤拷锟�
+    [Header("移动属性")]
+    public Vector2 moveVec;         //玩家不动时移动数据
     [HideInInspector]
     public Vector2 leftDir;
 
-    [Header("锟斤拷锟斤拷锟斤拷锟�")]
+    [Header("冲刺属性")]
     public float rushSpeed = 100;
     public float rushCostMp = 5;
     public Vector3 rushDir;
@@ -91,43 +91,43 @@ public class PlayerController : MoveCharacter
     public float rushTime;
     public float totalRushTime = 0.5f;
     [HideInInspector]
-    public float cacheRushTime; //锟睫凤拷Rush时锟斤拷锟斤拷Rush锟斤拷锟斤拷锟斤拷Rush锟斤拷锟街感诧拷锟矫ｏ拷锟斤拷锟芥几帧锟斤拷锟斤拷锟解几帧锟斤拷锟斤拷鼗锟斤拷锟斤拷锟絉ush;
+    public float cacheRushTime; //无法Rush时按下Rush键不会Rush，手感不好，缓存几帧，在这几帧内落地会立即Rush;
     public float totalCacheRushTime = 0.1f;
 
-    [Header("锟斤拷锟斤拷锟斤拷锟斤拷")]
+    [Header("链条属性")]
     public float sprintCostMp = 5;
     [HideInInspector]
     public float cachePullRopeTime;
     public float totalCachePullRopeTime = 0.1f;
 
-    [Header("锟斤拷跃锟斤拷锟斤拷")]
+    [Header("跳跃属性")]
     public float jumpSpeed = 10;
     public float airJumpSpeed = 10;
     public int airJumped;
-    public int airJumpNumber = 1;  //锟斤拷锟斤拷锟皆撅拷锟斤拷锟�
-    public float canAirJumpSpeed = 5;//y锟斤拷锟劫度达拷锟斤拷锟斤拷锟街凳憋拷锟斤拷芙锟斤拷锌锟斤拷锟斤拷锟皆�
+    public int airJumpNumber = 1;  //最大跳跃次数
+    public float canAirJumpSpeed = 5;//y轴速度大于这个值时不能进行空中跳跃
     [HideInInspector]
-    public float canJumpTime; //锟诫开平台锟斤拷锟斤拷然锟斤拷锟斤拷锟斤拷跃锟斤拷时锟戒，锟斤拷锟斤拷锟斤拷锟斤拷锟街革拷
+    public float canJumpTime; //离开平台后仍然可以跳跃的时间，用于提升手感
     public float leaveGroundCanJumpTime = 0.1f;
     [HideInInspector]
-    public float cacheJumpTime; //锟斤拷锟斤拷锟斤拷锟绞憋拷锟斤拷锟斤拷锟皆撅拷锟斤拷锟斤拷锟斤拷锟皆撅拷锟斤拷指胁锟斤拷茫锟斤拷锟斤拷婕钢★拷锟斤拷锟斤拷饧钢★拷锟斤拷锟截伙拷锟斤拷锟斤拷锟斤拷跃;
+    public float cacheJumpTime; //即将落地时按下跳跃键不会跳跃，手感不好，缓存几帧，在这几帧内落地会立即跳跃;
     public float totalCacheJumpTime = 0.1f;
 
-    [Header("锟斤拷锟斤拷锟斤拷锟斤拷")]
+    [Header("飞行属性")]
     public float flySpeed = 5;
     public float maxFlyHeight;
 
-    [Header("锟劫伙拷锟斤拷锟斤拷")]
-    public float cacheDir;  //锟劫伙拷锟斤拷时锟斤拷锟斤拷锟斤拷锟劫伙拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷应锟街感诧拷锟矫ｏ拷锟斤拷锟斤拷一锟铰ｏ拷锟劫伙拷锟斤拷摇锟节硷拷锟斤拷锟斤拷锟斤拷锟斤拷应锟侥伙拷锟斤拷转锟斤拷
+    [Header("召唤属性")]
+    public float cacheDir;  //召唤的时候按左右召唤结束不会响应手感不好，缓存一下，召唤后摇期间有左右响应的话会转向
     [HideInInspector]
     public float summonTime;
     [HideInInspector]
-    public float cacheSummonTime; //锟睫凤拷锟劫伙拷时锟斤拷锟斤拷锟劫伙拷锟斤拷锟斤拷锟斤拷锟劫伙拷锟斤拷锟街感诧拷锟矫ｏ拷锟斤拷锟芥几帧锟斤拷锟斤拷锟解几帧锟斤拷锟斤拷鼗锟斤拷锟斤拷锟斤拷倩锟�;
+    public float cacheSummonTime; //无法召唤时按下召唤键不会召唤，手感不好，缓存几帧，在这几帧内落地会立即召唤;
     [HideInInspector]
     public int cacheSummonId;
 
 
-    [Header("锟劫伙拷使魔")]
+    [Header("召唤使魔")]
     public List<GameObject> demonicPrefabs;
     public List<Vector3> demonicSummonPos;
     public Dictionary<int, List<Demonic>> demonicDic;
@@ -135,80 +135,80 @@ public class PlayerController : MoveCharacter
     private List<Demonic> giants = new List<Demonic>();
     private List<Demonic> swords = new List<Demonic>();
 
-    [Header("锟斤拷锟斤拷")]
+    [Header("攻击")]
     public PlayerAttackState attackState;
     public float attackMoveSpeed = 5f;
     [HideInInspector]
-    public float cacheAttackTime; //锟睫凤拷锟斤拷锟斤拷时锟斤拷锟铰癸拷锟斤拷锟斤拷锟斤拷锟结攻锟斤拷锟斤拷锟街感诧拷锟矫ｏ拷锟斤拷锟芥几帧锟斤拷锟斤拷锟解几帧锟斤拷锟斤拷鼗锟斤拷锟斤拷锟斤拷锟斤拷锟�;
+    public float cacheAttackTime; //无法攻击时按下攻击键不会攻击，手感不好，缓存几帧，在这几帧内落地会立即攻击;
     public float totalCacheAttackTime = 0.1f;
 
-    [Header("锟斤拷锟斤拷")]
-    public float reviveTime;        //锟斤拷锟斤拷时锟斤拷
+    [Header("复活")]
+    public float reviveTime;        //复活时间
     public float totalReviveTime;
 
-    [Header("锟斤拷锟斤拷欠锟斤拷诨锟斤拷锟�")]
+    [Header("玩家是否在基地")]
     public bool isBaseBtnOut = false;
 
-    [Header("锟斤拷锟斤拷")]
+    [Header("八卦")]
     public ChooseYinYang chooseYinYang;
 
-    [Header("锟斤拷锟斤拷锟斤拷")]
+    [Header("锁魂塔")]
     public GameObject curSoulTower;
 
-    //指锟接癸拷锟斤拷
-    private float conductTime;          //指锟接帮拷锟斤拷锟斤拷锟斤拷时锟斤拷
-    private int nowConductButton = -1;     //锟斤拷锟节帮拷锟铰碉拷指锟接硷拷锟斤拷0.J/1.K/2.L/-1.锟睫ｏ拷
+    //指挥功能
+    private float conductTime;          //指挥按键长按时间
+    private int nowConductButton = -1;     //现在按下的指挥键（0.J/1.K/2.L/-1.无）
     private int cacheConductId;
-    [Header("锟劫伙拷锟斤拷应时锟斤拷")] [Tooltip("锟节达拷时锟斤拷锟斤拷锟斤拷锟斤拷为锟劫伙拷")] public float totalCacheSummonTime;
-    [Header("指锟斤拷锟斤拷应时锟斤拷")] [Tooltip("锟节达拷时锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷为指锟斤拷")] public float[] canConductTime;
-    [Header("指锟接硷拷锟斤拷")] [Tooltip("选锟斤拷锟斤拷应锟斤拷指锟接硷拷锟斤拷")] public ConductSkills[] conductSkills;
-    public bool[] conductCanRelease;        //锟杰凤拷锟斤拷锟街革拷蛹锟斤拷锟斤拷锟阶刺�
-    public ConductReadyTip conductReadyTip; //指锟接硷拷锟斤拷锟斤拷
+    [Header("召唤相应时间")] [Tooltip("在此时间内松手为召唤")] public float totalCacheSummonTime;
+    [Header("指挥相应时间")] [Tooltip("在此时间以外松手为指挥")] public float[] canConductTime;
+    [Header("指挥技能")] [Tooltip("选择相应的指挥技能")] public ConductSkills[] conductSkills;
+    public bool[] conductCanRelease;        //能否进入指挥技蓄力状态
+    public ConductReadyTip conductReadyTip; //指挥技就绪
     private bool isReadyConduct;
-    [Header("时锟戒倍锟斤拷")] [Tooltip("时锟斤拷锟劫度凤拷锟斤拷锟斤拷锟斤拷锟斤拷锟侥硷拷锟斤拷")] public float timeSlowingMultiplier;
+    [Header("时间倍率")] [Tooltip("时间速度放慢到正常的几倍")] public float timeSlowingMultiplier;
     public float readyTipFxTime;
-    [Header("转锟斤拷锟斤拷")] public float[] conversionRate;
-    //锟斤拷锟斤拷锟斤拷
-    [Header("锟节猴拷锟斤拷时血锟斤拷锟斤拷锟斤拷")] public int temptHp;
-    [Header("锟节猴拷血锟斤拷锟斤拷锟斤拷时锟斤拷")]public float temptTime;
+    [Header("转换率")] public float[] conversionRate;
+    //大胖子
+    [Header("融合临时血量基数")] public int temptHp;
+    [Header("融合血量持续时间")]public float temptTime;
     public GameObject[] bigGiant;
     public float[] stageSize;
     public int[] giantDieNum;
-    //锟斤拷锟斤拷
+    //光球
     public GameObject photosphereObj;
-    [Header("锟斤拷锟斤拷血锟斤拷锟斤拷锟斤拷")] public int photosphereHp;
-    //锟斤拷锟斤拷锟斤拷
+    [Header("光球血量基数")] public int photosphereHp;
+    //攻击力
     public GameObject attackEffect;
-    //泰山压锟斤拷
+    //泰山压顶
     public GameObject mountain;
     public Vector3 mountainOffset;
-    //锟斤拷锟斤拷锟斤拷
+    //气功波
     public GameObject wavePowerObj;
-    [Header("锟斤拷锟斤拷锟斤拷锟剿猴拷锟斤拷锟斤拷")]public int wavePowerDamage;
-    //锟斤拷锟斤拷锟斤拷
+    [Header("气功波伤害基数")]public int wavePowerDamage;
+    //御剑术
     public GameObject flyingSwordsObj;
-    [Header("锟斤拷锟斤拷锟斤拷锟剿猴拷")] public int swordsDamage;
-    //怨锟斤拷锟斤拷
+    [Header("御剑术伤害")] public int swordsDamage;
+    //怨气弹
     public GameObject angryBulletObj;
-    [Header("怨锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷")] public int angryBulletNum;
-    //锟斤拷锟轿飞斤拷
+    [Header("怨气弹数量基数")] public int angryBulletNum;
+    //扇形飞剑
     public GameObject fanFlyingSwords;
-    [Header("锟缴斤拷锟角度凤拷围")]public float flyingSwordsAngleRange;
-    [Header("锟缴斤拷锟角讹拷锟斤拷锟斤拷锟�")] public float flyintSwordsArrivalAngle;
-    [Header("锟缴斤拷锟斤拷锟斤拷锟斤拷锟斤拷")] public int flyingSwordsNum;
+    [Header("飞剑角度范围")]public float flyingSwordsAngleRange;
+    [Header("飞剑角度入射角")] public float flyintSwordsArrivalAngle;
+    [Header("飞剑数量基数")] public int flyingSwordsNum;
 
     public enum ConductSkills
     {
-        Giant,              //锟斤拷锟接ｏ拷锟较成达拷锟斤拷锟斤拷
-        Photosphere,        //锟斤拷锟接ｏ拷锟斤拷锟斤拷
-        AddAttack,          //锟斤拷锟接ｏ拷锟斤拷锟接癸拷锟斤拷锟斤拷
+        Giant,              //胖子：合成大胖子
+        Photosphere,        //胖子：光球
+        AddAttack,          //胖子：增加攻击力
 
-        Mountain,           //锟斤拷锟斤拷师锟斤拷泰山压锟斤拷
-        WavePower,          //锟斤拷锟斤拷师锟斤拷锟斤拷锟斤拷锟斤拷
-        SwordsControl,      //锟斤拷锟斤拷师锟斤拷锟斤拷锟斤拷锟斤拷
+        Mountain,           //气功师：泰山压顶
+        WavePower,          //气功师：气功波
+        SwordsControl,      //气功师：御剑术
 
-        AngryBullet,        //锟斤拷锟斤拷锟街ｏ拷怨锟斤拷锟斤拷
-        FlyingSwords,     //锟斤拷锟轿飞斤拷
+        AngryBullet,        //弓箭手：怨气弹
+        FlyingSwords,     //扇形飞剑
     }
 
 
@@ -415,7 +415,7 @@ public class PlayerController : MoveCharacter
                 SpiritSystem.player2 = gameObject;
                 SpiritSystem.p2Spirits = GetComponent<Spirits>();
 
-                //锟叫伙拷为双锟剿硷拷锟斤拷锟斤拷锟斤拷锟斤拷式
+                //切换为双人计算蓝量方式
                 PlayerController p1 = PlayersInput.instance[0];
                 mpReplySpeed = mpReplySpeed_2Players;
                 p1.mpReplySpeed = mpReplySpeed_2Players;
@@ -455,7 +455,7 @@ public class PlayerController : MoveCharacter
         {
             CharacterFloat();
         }
-        /*  //锟斤拷时锟斤拷锟皆讹拷锟斤拷锟斤拷锟斤拷锟�
+        /*  //到时间自动解除变身
         if (endChange != 0)
         {
             pastChangeTime += Time.deltaTime;
@@ -507,10 +507,10 @@ public class PlayerController : MoveCharacter
     {
         LBisHold = false;
     }
-    //锟街憋拷锟斤拷锟斤拷LB
+    //手柄按下LB
     [HideInInspector]
     public bool LBisHold;
-    //锟斤拷取锟街憋拷锟斤拷锟斤拷
+    //读取手柄参数
     private void OnMove(InputValue value)
     {
         if (canMove)
@@ -591,7 +591,7 @@ public class PlayerController : MoveCharacter
         }
     }
 
-    //选英锟斤拷 锟斤拷锟街憋拷锟揭帮拷锟斤拷锟斤拷锟斤拷锟絋AB锟斤拷
+    //选英灵 （手柄右扳机，键盘TAB）
     void OnChooseSpirit()
     {
         switch (playerId)
@@ -607,14 +607,14 @@ public class PlayerController : MoveCharacter
         }
     }
 
-    //选英锟介（锟街憋拷锟斤拷摇锟剿ｏ拷小锟斤拷锟斤拷锟斤拷锟揭ｏ拷
+    //选英灵（手柄右摇杆，小键盘左右）
     void OnChooseSpirit_LR(InputValue value)
     {
         rightDir = value.Get<Vector2>();
 
     }
 
-    //锟劫伙拷英锟斤拷
+    //召唤英灵
     void OnTransfigurate()
     {
         if (!keyTransfigurateRelease && !isFloat && canMove && !isBaseBtnOut)
@@ -623,7 +623,7 @@ public class PlayerController : MoveCharacter
         }
     }
 
-    //锟缴匡拷锟斤拷锟斤拷英锟斤拷锟�
+    //松开变身英灵键
     void OnTransfigurateUp()
     {
         if (!isBaseBtnOut)
@@ -770,7 +770,7 @@ public class PlayerController : MoveCharacter
             }
             switch (conductSkills[cacheConductId])
             {
-                //锟斤拷锟斤拷
+                //胖子
                 case ConductSkills.Giant:
                     GameObject demonicObj = PoolManager.Instantiate(bigGiant[cacheConductId]);
                     Demonic demonic = demonicObj.GetComponent<Demonic>();
@@ -840,7 +840,7 @@ public class PlayerController : MoveCharacter
                     //    }
                     //}
                     break;
-                //锟斤拷锟斤拷师
+                //气功师
                 case ConductSkills.Mountain:
                     conductCanRelease[cacheConductId] = false;
                     GameObject curMountain = Instantiate(mountain, null);
@@ -872,7 +872,7 @@ public class PlayerController : MoveCharacter
                     swordsControl.conductId = cacheConductId;
                     swordsControl.damage = swordsDamage * boostNum;
                     break;
-                //锟斤拷锟斤拷锟斤拷
+                //弓箭手
                 case ConductSkills.AngryBullet:
                     conductCanRelease[cacheConductId] = false;
                     obj = Instantiate(angryBulletObj);
@@ -894,13 +894,13 @@ public class PlayerController : MoveCharacter
         }
         else
         {
-            print("使魔锟斤拷锟斤拷");
+            print("使魔不足");
         }
     }
 
 
 
-    //锟斤拷色锟斤拷锟节匡拷锟斤拷锟缴活动状态时锟斤拷通锟斤拷锟叫伙拷状态锟竭硷拷锟斤拷锟斤拷Idle锟斤拷Run状态锟斤拷锟皆硷拷锟斤拷锟阶刺�拷锟斤拷锟绞弊硷拷锟斤拷氐锟絀dle状态前
+    //角色处于可自由活动状态时的通用切换状态逻辑，如Idle、Run状态，以及别的状态结束时准备回到Idle状态前
     public bool CheckPlayerChangeState(CharacterState excludeState = CharacterState.None)
     {
         if (!foot.TrigGround)
@@ -1226,14 +1226,14 @@ public class PlayerController : MoveCharacter
                 rb.linearVelocity = AirMove(rb.linearVelocity);
                 break;
             //case CharacterState.Hurt:
-            //    if (hurtKeepTime <= 0 && rb.velocity.magnitude < hurtChangeVelocity)
+            //    if (hurtKeepTime <= 0 && rb.linearVelocity.magnitude < hurtChangeVelocity)
             //    {
             //        if (CheckPlayerChangeState())
             //        {
             //            break;
             //        }
             //    }
-            //    Vector3 vel = rb.velocity;
+            //    Vector3 vel = rb.linearVelocity;
             //    if (!foot.TrigGround)
             //    {
             //        if (canfly)
@@ -1247,7 +1247,7 @@ public class PlayerController : MoveCharacter
 
             //    }
             //    vel.x = vel.x * (1 - decelerationRatio * Time.deltaTime);
-            //    rb.velocity = vel;
+            //    rb.linearVelocity = vel;
             //    CachedPlayerInput();
             //    break;
             case CharacterState.Coma:
@@ -1959,12 +1959,12 @@ public class PlayerController : MoveCharacter
         return velocity;
     }
 
-    public void Transfiguration(int id) //锟斤拷锟斤拷
+    public void Transfiguration(int id) //变身
     {
         id = id - 3;
         if (id >= changePrefabs.Count)
         {
-            Debug.LogError("未锟斤拷锟斤拷" + id + "锟脚憋拷锟斤拷");
+            Debug.LogError("未配置" + id + "号变身");
             return;
         }
         GameObject prefab = changePrefabs[id];
@@ -2014,7 +2014,7 @@ public class PlayerController : MoveCharacter
             canJump = false;
             rb.useGravity = false;
         }
-        /*  锟斤拷师锟斤拷锟斤拷锟酵放革拷锟秸筹拷
+        /*  法师出场释放浮空场
         if (id == 3)
         {
             if ((int)spirits.currentSpirit == 0)
@@ -2038,12 +2038,12 @@ public class PlayerController : MoveCharacter
     {
         if (id >= demonicPrefabs.Count)
         {
-            Debug.LogError("未锟斤拷锟斤拷" + id + "锟斤拷使魔");
+            Debug.LogError("未配置" + id + "号使魔");
             return;
         }
         if (id >= demonicSummonPos.Count)
         {
-            Debug.LogError("未锟斤拷锟斤拷" + id + "锟斤拷使魔锟劫伙拷位锟斤拷");
+            Debug.LogError("未配置" + id + "号使魔召唤位置");
             return;
         }
         GameObject prefab;
@@ -2106,7 +2106,7 @@ public class PlayerController : MoveCharacter
         {
             demonic.Attack1();
         }
-        //id 3~6 为锟侥革拷英锟斤拷
+        //id 3~6 为四个英灵
         if (id >= 3 && id <= 6)
         {
             spirits.ultimateTimes[spirits.nowSpirit] -= 1;
@@ -2147,7 +2147,7 @@ public class PlayerController : MoveCharacter
         float costMp = prefab.GetComponent<Demonic>().costMp;
         if (mp < costMp)
         {
-            Debug.Log("mp锟斤拷锟斤拷锟劫伙拷失锟斤拷, 锟斤拷锟矫加革拷锟斤拷锟斤拷锟斤拷锟斤拷锟斤拷效啥锟斤拷");
+            Debug.Log("mp不足召唤失败, 还得加个动画或者音效啥的");
             return false;
         }
         return true;

ActionTowerDefense/Assets/Scripts/Portal/PortalsController.cs

@@ -4,11 +4,11 @@ using UnityEngine;
 
 public class PortalsController : MonoBehaviour
 {
-    public PortalsController targetPortal;              //锟斤拷锟斤拷目锟斤拷
-    public List<Rigidbody> rbs = new List<Rigidbody>(); //通锟斤拷锟斤拷前锟斤拷锟斤拷锟脚的碉拷位
-    public float TransmitCD;                            //每锟斤拷锟斤拷位锟斤拷锟酵碉拷CD
-    public bool isReverse;                              //锟斤拷锟斤拷锟脚筹拷锟斤拷锟角凤拷锟洁反
-    public bool onlyEnemy;                              //锟角凤拷只锟杰达拷锟酵碉拷锟斤拷
+    public PortalsController targetPortal;              //传送目标
+    public List<Rigidbody> rbs = new List<Rigidbody>(); //通过当前传送门的单位
+    public float TransmitCD;                            //每个单位传送的CD
+    public bool isReverse;                              //传送门朝向是否相反
+    public bool onlyEnemy;                              //是否只能传送敌人
 
     private void OnTriggerEnter(Collider other)
     {
@@ -16,7 +16,7 @@ public class PortalsController : MonoBehaviour
         {
             return;
         }
-        //锟斤拷锟斤拷锟斤拷锟角★拷使魔锟斤拷锟斤拷锟斤拷
+        //传送主角、使魔、敌人
         BeSearchTrigger beSearchTrigger = other.GetComponent<BeSearchTrigger>();
         if (beSearchTrigger != null)
         {
@@ -41,7 +41,7 @@ public class PortalsController : MonoBehaviour
             }
             return;
         }
-        //锟斤拷锟斤拷锟接碉拷
+        //传送子弹
         Bullet bullet = other.GetComponent<Bullet>();
         if(bullet != null && bullet.canTransmit)
         {
@@ -54,7 +54,7 @@ public class PortalsController : MonoBehaviour
             }
             return;
         }
-        //锟斤拷锟酵伙拷
+        //传送魂
         Soul soul = other.GetComponent<Soul>();
         if(soul != null)
         {
@@ -69,7 +69,7 @@ public class PortalsController : MonoBehaviour
         }
     }
 
-    //锟斤拷锟斤拷
+    //传送
     public bool Transmit(Rigidbody rb)
     {
        

ActionTowerDefense/Assets/Scripts/Soul.cs

@@ -26,14 +26,14 @@ public class Soul : MonoBehaviour
 
     public bool Spirits_Invisible_NotFind;
 
-    [Header("锟斤拷锟斤拷锟斤拷")]
-    public bool haveTransmit;           //锟秸达拷锟酵癸拷
+    [Header("传送门")]
+    public bool haveTransmit;           //刚传送过
     [HideInInspector]
-    public float transmitTime;          //锟斤拷锟斤拷CD
+    public float transmitTime;          //传送CD
     public PortalsController portalsController;
 
-    [Header("锟较伙拷")]
-    public bool isSourPurple;           //锟角凤拷锟斤拷锟较伙拷
+    [Header("紫魂")]
+    public bool isSourPurple;           //是否是紫魂
     public Spirits.SpiritType type;
     public SpiritSystem spiritSystem;
 

ActionTowerDefense/Assets/Scripts/Spirits/ESpirits_Invisible.cs

@@ -4,13 +4,13 @@ using UnityEngine;
 public enum InvisibleState
 {
     None = -1,
-    Normal = 0, //占쏙옙占쏙옙榴檄
-    Hurt = 1,   //占쏙옙占쏙옙榴檄
-    FindSoul = 2,   //占쌀삼옙榴檄
-    FindPlayer = 3, //占쏙옙占쏙옙占�
-    Boom = 4,   //占쏙옙珞
-    Die = 5,    //占쏙옙占쏙옙
-    Wait = 6,   //占쏙옙占쏙옙女占쏙옙占�
+    Normal = 0, //攣끽榴檄
+    Hurt = 1,   //굳댔榴檄
+    FindSoul = 2,   //冷산榴檄
+    FindPlayer = 3, //冷鯤소
+    Boom = 4,   //괵珞
+    Die = 5,    //价空
+    Wait = 6,   //된鯤소놔쳔
 }
 public class ESpirits_Invisible : MonoBehaviour
 {

ActionTowerDefense/Assets/Scripts/Spirits/Spirits_Dash.cs

@@ -14,15 +14,15 @@ public class Spirits_Dash : MonoBehaviour
     public float offset;
     public DashEffect dashEffect;
 
-    [Header("����")]
-    public PlayerController playerController;   //�ٻ������
+    [Header("µ÷ÓÃ")]
+    public PlayerController playerController;   //ÕÙ»½µÄÍæ¼Ò
     public Animator animator;
 
-    [Header("���")]
-    public Vector3 targetDir;       //��̷���
-    public GameObject aimEffect;    //��׼��
-    public float rushSpeed;         //����ٶ�
-    public float dashTime;          //���ʱ��
+    [Header("³å´Ì")]
+    public Vector3 targetDir;       //³å´Ì·½Ïò
+    public GameObject aimEffect;    //Ãé×¼Ïß
+    public float rushSpeed;         //³å´ÌËÙ¶È
+    public float dashTime;          //³å´Ìʱ¼ä
 
     private void Start()
     {
@@ -73,7 +73,7 @@ public class Spirits_Dash : MonoBehaviour
         rb.linearVelocity = Vector3.zero;
     }
 
-    //���
+    //³å´Ì
     private void Dash()
     {
         if (targetDir == Vector3.zero)
@@ -107,7 +107,7 @@ public class Spirits_Dash : MonoBehaviour
         demonic.rb.linearVelocity = targetDir * rushSpeed;
     }
 
-    //����
+    //ÐîÁ¦
     public void ReadyToDash(Vector2 leftDir)
     {
         if (leftDir == Vector2.zero)

ActionTowerDefense/Assets/Scripts/Spirits/Trans_Assassin.cs

@@ -5,20 +5,20 @@ using UnityEngine.InputSystem;
 public enum Trans_AssassinState
 {
     None = -1,
-    Normal = 0,         //锟斤拷锟斤拷状态
-    ReadyToRush = 1,    //准锟斤拷锟斤拷锟阶刺�
-    Rush = 2,           //锟斤拷锟阶刺�
-    HaveRush = 3,       //锟窖筹拷锟揭伙拷锟阶刺�
-    ReadyToSecondRush = 4,  //锟节讹拷锟斤拷准锟斤拷锟斤拷锟阶刺�
-    SecondRush = 5,     //锟节讹拷锟轿筹拷锟�
+    Normal = 0,         //正常状态
+    ReadyToRush = 1,    //准备冲刺状态
+    Rush = 2,           //冲刺状态
+    HaveRush = 3,       //已冲刺一次状态
+    ReadyToSecondRush = 4,  //第二次准备冲刺状态
+    SecondRush = 5,     //第二次冲刺
 }
 
 public class Trans_Assassin : MonoBehaviour
 {
 
     public PlayerController player;
-    public float criticalChance;            //锟斤拷锟斤拷锟斤拷
-    public float criticalMultiplier;        //锟斤拷锟斤拷锟斤拷锟斤拷
+    public float criticalChance;            //暴击率
+    public float criticalMultiplier;        //暴击倍数
     [HideInInspector]
     public float distance;
     public float rushSpeed;

ActionTowerDefense/Assets/Scripts/Spirits/Trans_Invisible.cs

@@ -147,7 +147,7 @@ public class Trans_Invisible : MonoBehaviour
         GameObject soulObj = Instantiate(soulPrefab);
         Soul soul = soulObj.GetComponent<Soul>();
         soul.from = shootPos.transform.position;
-        if (playerController.rb.velocity == Vector3.zero)
+        if (playerController.rb.linearVelocity == Vector3.zero)
         {
             if (body.localScale.x > 0)
             {
@@ -160,7 +160,7 @@ public class Trans_Invisible : MonoBehaviour
         }
         else
         {
-            soul.to = transform.position + playerController.rb.velocity.normalized * distance;
+            soul.to = transform.position + playerController.rb.linearVelocity.normalized * distance;
         }
 
         soul.isShoot = true;

ActionTowerDefense/Assets/Scripts/SystemReflect/SingleScreenBorder.cs

@@ -6,10 +6,10 @@ public class SingleScreenBorder : MonoBehaviour
 {
     public ScreenCrash sc;
 
-    [Header("锟角凤拷锟斤拷锟叫�")]
+    [Header("是否可生效")]
     public bool canAffect;
 
-    [Header("锟斤拷锟截的讹拷锟斤拷锟斤拷锟侥革拷锟竭斤拷")]
+    [Header("挂载的对象是哪个边界")]
     public bool isUp;
     public bool isDown;
     public bool isLeft;

ActionTowerDefense/Assets/Scripts/Tower.cs

@@ -6,7 +6,7 @@ using TMPro;
 
 public class Tower : Character
 {
-    [Header("锟斤拷锟斤拷息")]
+    [Header("塔信息")]
     public bool isLockSoul;
     public float height = 8;
     private void Awake()
@@ -125,7 +125,7 @@ public class Tower : Character
     {
         hp -= damage;
 
-        //锟剿猴拷锟斤拷锟斤拷
+        //伤害跳字
         if (showInjuryNum)
         {
             GameObject injuryNum = Instantiate(injuryNumText);