真正给水猴子加上了动画，整理enemy代码把逃跑和爬树写到水猴子脚本中，水猴子在树上动画仍然有问题，攻击完不会转到待机动画，待修复

ActionTowerDefense/Assets/Resources/Prefab/Enemy/Enemy_1013.prefab

@@ -29,7 +29,7 @@ Transform:
   m_GameObject: {fileID: 1829166066747205364}
   m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
   m_LocalPosition: {x: 0, y: 0, z: 0}
-  m_LocalScale: {x: 0.5, y: 0.5, z: 1}
+  m_LocalScale: {x: -0.5, y: 0.5, z: 1}
   m_ConstrainProportionsScale: 0
   m_Children: []
   m_Father: {fileID: 3854405717744093724}
@@ -63,7 +63,7 @@ MeshRenderer:
   m_RenderingLayerMask: 1
   m_RendererPriority: 0
   m_Materials:
-  - {fileID: 2100000, guid: b7edeeccb78d01040b4cf54ef692b33e, type: 2}
+  - {fileID: 2100000, guid: 09c7db0319f32504ca14a4af7d08ebeb, type: 2}
   m_StaticBatchInfo:
     firstSubMesh: 0
     subMeshCount: 0
@@ -95,7 +95,7 @@ Animator:
   m_GameObject: {fileID: 1829166066747205364}
   m_Enabled: 1
   m_Avatar: {fileID: 0}
-  m_Controller: {fileID: 9100000, guid: 43cdd0519d3bd8b4a87d185264324697, type: 2}
+  m_Controller: {fileID: 9100000, guid: 739ebff4c37914745b9b5b208cda02af, type: 2}
   m_CullingMode: 0
   m_UpdateMode: 0
   m_ApplyRootMotion: 0
@@ -117,8 +117,8 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: f9db98c60740638449864eb028fbe7ad, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  skeletonDataAsset: {fileID: 11400000, guid: 58247c7eefdd8b14981d0d3105784866, type: 2}
-  initialSkinName: enermy
+  skeletonDataAsset: {fileID: 11400000, guid: f3f78089538c68e44a63193821a172bb, type: 2}
+  initialSkinName: 
   fixPrefabOverrideViaMeshFilter: 2
   initialFlipX: 0
   initialFlipY: 0
@@ -146,7 +146,7 @@ MonoBehaviour:
   translator:
     autoReset: 1
     useCustomMixMode: 1
-    layerMixModes: 01000000
+    layerMixModes: 00000000
     layerBlendModes: 01000000
   updateTiming: 1
 --- !u!1 &2130254855421188871
@@ -238,7 +238,7 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: 0b26741a8a1605241bfcb96615276db9, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  owner: {fileID: 0}
+  owner: {fileID: 9068622316821004187}
   arrow: {fileID: 775116544085328787, guid: b0593518d25973c41859696aef316f19, type: 3}
   num: 1
   angle: 0
@@ -293,7 +293,7 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: 21f006d2c845e2e43bce70ea7a2d8dcc, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  owner: {fileID: 4354959530494727753}
+  owner: {fileID: 0}
   trigDemonicList: []
   trigTowerList: []
   trigPlayerList: []
@@ -548,7 +548,7 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: 8b2c8973c65adf4448805aa906f6ad29, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  owner: {fileID: 4354959530494727753}
+  owner: {fileID: 0}
   attackerID: 0
   curX: 0
 --- !u!114 &6581720511662537704
@@ -755,7 +755,7 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: 8ff1eeae99d9b8142acd628550a50e26, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  owner: {fileID: 4354959530494727753}
+  owner: {fileID: 0}
 --- !u!1 &5107797234459531787
 GameObject:
   m_ObjectHideFlags: 0
@@ -841,7 +841,7 @@ GameObject:
   serializedVersion: 6
   m_Component:
   - component: {fileID: 5971333975937033843}
-  - component: {fileID: 4354959530494727753}
+  - component: {fileID: 9068622316821004187}
   - component: {fileID: 7670319919627942488}
   - component: {fileID: 5971333975937033852}
   m_Layer: 8
@@ -866,11 +866,10 @@ Transform:
   - {fileID: 3854405717744093724}
   - {fileID: 6594048782185940104}
   - {fileID: 3619940638383525585}
-  - {fileID: 118782066522494837}
   m_Father: {fileID: 0}
   m_RootOrder: 0
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!114 &4354959530494727753
+--- !u!114 &9068622316821004187
 MonoBehaviour:
   m_ObjectHideFlags: 0
   m_CorrespondingSourceObject: {fileID: 0}
@@ -879,7 +878,7 @@ MonoBehaviour:
   m_GameObject: {fileID: 5971333975937033846}
   m_Enabled: 1
   m_EditorHideFlags: 0
-  m_Script: {fileID: 11500000, guid: 7475a7d33f657b146a4994b1e02710ad, type: 3}
+  m_Script: {fileID: 11500000, guid: f618e99d71df88348bd4645872c17996, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
   rb: {fileID: 5971333975937033852}
@@ -892,11 +891,11 @@ MonoBehaviour:
   attackController: {fileID: 7670319919627942488}
   platform: {fileID: 0}
   mecanim: {fileID: 4537717762058977136}
-  meshRenderer: {fileID: 5849088671716896657}
+  meshRenderer: {fileID: 0}
   ani: {fileID: 2964753049365590755}
   totalDieKeepTime: 1
-  totalAttack_summonTime: 1.8333334
-  totalAttack_marchTime: 1.8333334
+  totalAttack_summonTime: 1.833333
+  totalAttack_marchTime: 1.833333
   showInjuryNum: 1
   injuryNumText: {fileID: 6467251191553420251, guid: 9b37289f93ea76745ab2cefb79a93e3c, type: 3}
   injuryNumTextSummon: {fileID: 6467251191553420251, guid: 71b4c570c9e403d429846b71878a20c4, type: 3}
@@ -909,8 +908,8 @@ MonoBehaviour:
   attackDis: 0
   targetCharacter: {fileID: 0}
   attackTarget: {fileID: 0}
-  state: 1
-  totalHp: 40
+  state: 0
+  totalHp: 100
   hp: 0
   canFly: 0
   canControlFly: 0
@@ -947,11 +946,9 @@ MonoBehaviour:
   spinee: {fileID: 0}
   mesh: {fileID: 0}
   mats: []
-  outlineMats:
-  - {fileID: 2100000, guid: 7d50f910288e95b4285a5fb549c94fe6, type: 2}
-  outline1Mats:
-  - {fileID: 2100000, guid: 79dada70fee9fbc49a327168481d3def, type: 2}
-  moveSpeed: 5.59073
+  outlineMats: []
+  outline1Mats: []
+  moveSpeed: 5
   needToAdjustFlyHeight: 0
   flyHeight: 0
   maxFlyHeight: 0
@@ -991,23 +988,20 @@ MonoBehaviour:
   reboundXSpeed: 0
   reboundYSpeed: 0
   wallDamage: 0
-  type: -1
+  type: 0
   searchState: 0
   attackRatio: 0
   dropSoulMax: 1
   dropSoulMin: 1
   dropProbability: 100
   dropSoulAngle: 90
-  canEscape: 1
-  stopEscapeCD: 2
-  escapeSpeed: 5
-  distanceToTowerDeviation: 1
-  distanceToTowerBase: 1.8
-  distanceToEnemyDeviation: 0.8
-  distanceToEnemyBase: 3
-  canClimb: 1
+  escapeSpeed: 8
+  distanceToTowerDeviation: 2
+  distanceToTowerBase: 4
+  distanceToEnemyDeviation: 4
+  distanceToEnemyBase: 2
+  climbSpeed: 5
   pathCreator: {fileID: 0}
-  climbSpeed: 2
 --- !u!114 &7670319919627942488
 MonoBehaviour:
   m_ObjectHideFlags: 0
@@ -1412,90 +1406,6 @@ MonoBehaviour:
   tryy: 0
   gravity: 40
   speed: 0
---- !u!1 &7460656627450706604
-GameObject:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  serializedVersion: 6
-  m_Component:
-  - component: {fileID: 118782066522494837}
-  - component: {fileID: 3169813074571257467}
-  m_Layer: 8
-  m_Name: Circle
-  m_TagString: Untagged
-  m_Icon: {fileID: 0}
-  m_NavMeshLayer: 0
-  m_StaticEditorFlags: 0
-  m_IsActive: 1
---- !u!4 &118782066522494837
-Transform:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 7460656627450706604}
-  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
-  m_LocalPosition: {x: 0, y: 0.63, z: 0}
-  m_LocalScale: {x: 1, y: 1, z: 1}
-  m_ConstrainProportionsScale: 0
-  m_Children: []
-  m_Father: {fileID: 5971333975937033843}
-  m_RootOrder: 3
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!212 &3169813074571257467
-SpriteRenderer:
-  m_ObjectHideFlags: 0
-  m_CorrespondingSourceObject: {fileID: 0}
-  m_PrefabInstance: {fileID: 0}
-  m_PrefabAsset: {fileID: 0}
-  m_GameObject: {fileID: 7460656627450706604}
-  m_Enabled: 1
-  m_CastShadows: 0
-  m_ReceiveShadows: 0
-  m_DynamicOccludee: 1
-  m_StaticShadowCaster: 0
-  m_MotionVectors: 1
-  m_LightProbeUsage: 1
-  m_ReflectionProbeUsage: 1
-  m_RayTracingMode: 0
-  m_RayTraceProcedural: 0
-  m_RenderingLayerMask: 1
-  m_RendererPriority: 0
-  m_Materials:
-  - {fileID: 10754, guid: 0000000000000000f000000000000000, type: 0}
-  m_StaticBatchInfo:
-    firstSubMesh: 0
-    subMeshCount: 0
-  m_StaticBatchRoot: {fileID: 0}
-  m_ProbeAnchor: {fileID: 0}
-  m_LightProbeVolumeOverride: {fileID: 0}
-  m_ScaleInLightmap: 1
-  m_ReceiveGI: 1
-  m_PreserveUVs: 0
-  m_IgnoreNormalsForChartDetection: 0
-  m_ImportantGI: 0
-  m_StitchLightmapSeams: 1
-  m_SelectedEditorRenderState: 0
-  m_MinimumChartSize: 4
-  m_AutoUVMaxDistance: 0.5
-  m_AutoUVMaxAngle: 89
-  m_LightmapParameters: {fileID: 0}
-  m_SortingLayerID: 341237651
-  m_SortingLayer: 3
-  m_SortingOrder: 0
-  m_Sprite: {fileID: -2413806693520163455, guid: a86470a33a6bf42c4b3595704624658b, type: 3}
-  m_Color: {r: 1, g: 0.20983982, b: 0, a: 1}
-  m_FlipX: 0
-  m_FlipY: 0
-  m_DrawMode: 0
-  m_Size: {x: 1, y: 1}
-  m_AdaptiveModeThreshold: 0.5
-  m_SpriteTileMode: 0
-  m_WasSpriteAssigned: 1
-  m_MaskInteraction: 0
-  m_SpriteSortPoint: 0
 --- !u!1 &7608239869512646950
 GameObject:
   m_ObjectHideFlags: 0

ActionTowerDefense/Assets/Resources/Prefab/Enemy/Enemy_Polliwog.prefab

@@ -934,16 +934,6 @@ MonoBehaviour:
   dropSoulMin: 0
   dropProbability: 30
   dropSoulAngle: 0
-  canEscape: 0
-  stopEscapeCD: 0
-  escapeSpeed: 0
-  distanceToTowerDeviation: 0
-  distanceToTowerBase: 0
-  distanceToEnemyDeviation: 0
-  distanceToEnemyBase: 0
-  canClimb: 0
-  pathCreator: {fileID: 0}
-  climbSpeed: 0
   playerTarget: {fileID: 0}
   separationWeight: 2.2
   cohesionWeight: 0.8

ActionTowerDefense/Assets/Resources/Prefab/Tree.prefab

@@ -240,8 +240,8 @@ BoxCollider:
   m_IsTrigger: 1
   m_Enabled: 1
   serializedVersion: 2
-  m_Size: {x: 0.43, y: 1, z: 1}
-  m_Center: {x: 0.48, y: -4.48, z: -4.2}
+  m_Size: {x: 0.43, y: 1, z: 5.2}
+  m_Center: {x: 0.48, y: -4.48, z: -1}
 --- !u!1 &2179150569397164390
 GameObject:
   m_ObjectHideFlags: 0

ActionTowerDefense/Assets/Resources/Spine/Enermy_Moneky/Monky_SkeletonData_Controller.controller

@@ -1,5 +1,31 @@
 %YAML 1.1
 %TAG !u! tag:unity3d.com,2011:
+--- !u!1102 &-6559718120018784347
+AnimatorState:
+  serializedVersion: 6
+  m_ObjectHideFlags: 1
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_Name: New State
+  m_Speed: 1
+  m_CycleOffset: 0
+  m_Transitions: []
+  m_StateMachineBehaviours: []
+  m_Position: {x: 50, y: 50, z: 0}
+  m_IKOnFeet: 0
+  m_WriteDefaultValues: 1
+  m_Mirror: 0
+  m_SpeedParameterActive: 0
+  m_MirrorParameterActive: 0
+  m_CycleOffsetParameterActive: 0
+  m_TimeParameterActive: 0
+  m_Motion: {fileID: 0}
+  m_Tag: 
+  m_SpeedParameter: 
+  m_MirrorParameter: 
+  m_CycleOffsetParameter: 
+  m_TimeParameter: 
 --- !u!74 &-6043979722677678078
 AnimationClip:
   m_ObjectHideFlags: 0
@@ -1161,31 +1187,34 @@ AnimatorStateMachine:
   m_ChildStates:
   - serializedVersion: 1
     m_State: {fileID: 2938919252573641149}
-    m_Position: {x: 200, y: 0, z: 0}
+    m_Position: {x: 310, y: -40, z: 0}
   - serializedVersion: 1
     m_State: {fileID: -3653197618492385787}
-    m_Position: {x: 235, y: 65, z: 0}
+    m_Position: {x: 310, y: 0, z: 0}
   - serializedVersion: 1
     m_State: {fileID: 5854448254552386370}
-    m_Position: {x: 270, y: 130, z: 0}
+    m_Position: {x: 310, y: 40, z: 0}
   - serializedVersion: 1
     m_State: {fileID: -3183910291419279386}
-    m_Position: {x: 305, y: 195, z: 0}
+    m_Position: {x: 310, y: 80, z: 0}
   - serializedVersion: 1
     m_State: {fileID: 1393044009220764331}
-    m_Position: {x: 340, y: 260, z: 0}
+    m_Position: {x: 310, y: 160, z: 0}
   - serializedVersion: 1
     m_State: {fileID: -1052511481193205878}
-    m_Position: {x: 375, y: 325, z: 0}
+    m_Position: {x: 310, y: 200, z: 0}
   - serializedVersion: 1
     m_State: {fileID: 2829229091825922686}
-    m_Position: {x: 410, y: 390, z: 0}
+    m_Position: {x: 310, y: 240, z: 0}
   - serializedVersion: 1
     m_State: {fileID: -192492218936817132}
-    m_Position: {x: 445, y: 455, z: 0}
+    m_Position: {x: 310, y: 120, z: 0}
   - serializedVersion: 1
     m_State: {fileID: 5435994347078006507}
-    m_Position: {x: 480, y: 520, z: 0}
+    m_Position: {x: 310, y: 280, z: 0}
+  - serializedVersion: 1
+    m_State: {fileID: -6559718120018784347}
+    m_Position: {x: 340, y: 330, z: 0}
   m_ChildStateMachines: []
   m_AnyStateTransitions: []
   m_EntryTransitions: []
@@ -1195,7 +1224,7 @@ AnimatorStateMachine:
   m_EntryPosition: {x: 50, y: 120, z: 0}
   m_ExitPosition: {x: 800, y: 120, z: 0}
   m_ParentStateMachinePosition: {x: 800, y: 20, z: 0}
-  m_DefaultState: {fileID: 2829229091825922686}
+  m_DefaultState: {fileID: -6559718120018784347}
 --- !u!74 &8812481164079486333
 AnimationClip:
   m_ObjectHideFlags: 0

ActionTowerDefense/Assets/Scripts/Characters/Character.cs

@@ -31,10 +31,6 @@ public enum CharacterState
 
     LockSoul = 25,          //ÔÚËø»êËþÖÐ
     Conduct = 26,           //ÔÚÖ¸»ÓÖÐ
-
-    Escape,
-    WaitForTank,
-    Climb
 }
 
 public class Character : MonoBehaviour

ActionTowerDefense/Assets/Scripts/Characters/Enemy.cs

@@ -1,5 +1,4 @@
 using OfficeOpenXml.FormulaParsing.Excel.Functions.Logical;
-using PathCreation;
 using Sirenix.OdinInspector;
 using Spine;
 using Spine.Unity;
@@ -68,11 +67,11 @@ public class Enemy : MoveCharacter
 
     [Header("攻击")]
     public float attackRatio;
-    private int curAttackID;
+    protected int curAttackID;
     private AttackController.AttackMethod[] am;
     private int len;
     protected float pastAttackTime;
-    private bool isConAttack;       //连续攻击，不切idle动画
+    protected bool isConAttack;       //连续攻击，不切idle动画
 
     [Header("掉落魂")]
     public int dropSoulMax = 3;
@@ -80,46 +79,15 @@ public class Enemy : MoveCharacter
     public int dropProbability = 100;
     public float dropSoulAngle = 60f;
 
-    [Header("逃跑组件")]
-    public bool canEscape = false;
-    private bool ShowEscapeValue() => canEscape;
-    [ShowIf("ShowEscapeValue")] public float stopEscapeCD;
-    [ShowIf("ShowEscapeValue")] public float escapeSpeed; //逃跑距离
-    [ShowIf("ShowEscapeValue")] public float distanceToTowerDeviation; //怪物逃跑靠近塔的距离偏差，防止怪物堆在一起
-    [ShowIf("ShowEscapeValue")] public float distanceToTowerBase; //怪物逃跑靠近塔的基础距离
-    [ShowIf("ShowEscapeValue")] public float distanceToEnemyDeviation; //怪物逃跑靠近坦克敌人的距离偏差，防止怪物堆在一起
-    [ShowIf("ShowEscapeValue")] public float distanceToEnemyBase; //怪物逃跑靠近坦克敌人的基础距离
-    private float distanceToTower;
-    private float distanceToEnemy;
-    private float stopEscapeTimer;
-    private EscapeTrigger escapeTrigger;
-
-    private bool ShowClimbValue() => canClimb;
-    [Header("爬树组件")]
-    public bool canClimb = false;
-    [ShowIf("ShowEscapeValue")] public PathCreator pathCreator;
-    [ShowIf("ShowEscapeValue")] public float climbSpeed;
-    private float dstTravelled;
-    private bool isArrived = false;
-    private float targetPoint;
-    private bool isOnTree = false;
-
     public override void Awake()
     {
         base.Awake();
-        if (canEscape)
-        {
-            searchTrigger.TryGetComponent<EscapeTrigger>(out escapeTrigger);
-            if (escapeTrigger == null) escapeTrigger = searchTrigger.AddComponent<EscapeTrigger>();
-        }
     }
 
-    private void Start()
+    protected virtual void Start()
     {
         am = attackController.attackMethod;
         len = am.Length;
-        distanceToTower = distanceToTowerBase;
-        distanceToEnemy = distanceToEnemyBase;
     }
 
     protected virtual void OnEnable()
@@ -275,10 +243,6 @@ public class Enemy : MoveCharacter
                     ChangeState(CharacterState.Rise);
                     break;
                 }
-                //if (CheckEscape())
-                //{
-                //    ChangeState(CharacterState.Escape);
-                //}
                 else if (isAttack)
                 {
                     if (pastAttackTime >= attackController.attackInterval)
@@ -325,11 +289,6 @@ public class Enemy : MoveCharacter
                 }
                 break;
             case CharacterState.Run:
-                //if (CheckEscape())
-                //{
-                //    ChangeState(CharacterState.Escape);
-                //}
-                /*else */
                 if (isAttack)
                 {
                     if (pastAttackTime >= attackController.attackInterval)
@@ -397,11 +356,7 @@ public class Enemy : MoveCharacter
                 }
                 break;
             case CharacterState.Rush:
-                if (CheckEscape())
-                {
-                    ChangeState(CharacterState.Escape);
-                }
-                else if (isAttack)
+                if (isAttack)
                 {
                     if (pastAttackTime >= attackController.attackInterval)
                     {
@@ -529,13 +484,7 @@ public class Enemy : MoveCharacter
                     {
                         isConAttack = true;
                     }
-                    if (CheckEscape() && !isOnTree)
-                    {
-                        ChangeState(CharacterState.Escape);
-                        return; 
-                    }
-                    if (isOnTree) ChangeState(CharacterState.Climb);
-                    else ChangeState(CharacterState.Idle);
+                    ChangeState(CharacterState.Idle);
                     break;
                 }
                 if (!foot.haveGravity)
@@ -583,93 +532,7 @@ public class Enemy : MoveCharacter
             case CharacterState.SpecialStatus_Weak:
                 attributeStatus.SpecialStateEffect(SpecialState.Weak);
                 break;
-            case CharacterState.Escape:
-                if (!foot.TrigGround && !canFly)
-                {
-                    if (rb.velocity.y > 0)
-                    {
-                        ChangeState(CharacterState.Rise);
-                        break;
-                    }
-                    else
-                    {
-                        ChangeState(CharacterState.Fall);
-                        break;
-                    }
-                }
-                velocity.x = -escapeSpeed;
-                if (bodyTrans.localScale.x < 0)
-                {
-                    Turn();
-                }
-                velocity.y = 0;
-                if (!foot.haveGravity)
-                {
-                    transform.position = new Vector3(transform.position.x, platformPosY, transform.position.z);
-                    targetQt = Quaternion.Euler(transform.rotation.eulerAngles.x, transform.rotation.eulerAngles.y, platformRotZ);
-                }
-                if (RotLerpTime < 1)
-                {
-                    RotLerpTime += RotLerpSpeed * Time.deltaTime;
-                    transform.rotation = Quaternion.Lerp(transform.rotation, targetQt, RotLerpTime);
-                }
-                else
-                {
-                    transform.rotation = targetQt;
-                }
-                rb.velocity = velocity;
-                AdjustHeight();
-                if (/*Time.time - stopEscapeTimer > stopEscapeCD && */escapeTrigger.IsSafe(distanceToEnemy))
-                {
-                    ChangeState(CharacterState.Run);
-                }
-                else if (escapeTrigger.IsInEnemyTower(distanceToTower))
-                {
-                    ChangeState(CharacterState.WaitForTank);
-                }
-                break;
-            case CharacterState.WaitForTank:
-                if (bodyTrans.localScale.x > 0)
-                {
-                    Turn();
-                }
-                if (escapeTrigger.IsSafe(distanceToEnemy))
-                {
-                    ChangeState(CharacterState.Run);
-                }
-                else if (isAttack)
-                {
-                    if (pastAttackTime >= attackController.attackInterval)
-                    {
-                        Attack_march();
-                    }
-                }
-                break;
-            case CharacterState.Climb:
-                if (!isArrived && pathCreator != null)
-                {
-                    float maxDistance = pathCreator.path.length * targetPoint;
-                    float moveStep = climbSpeed * Time.fixedDeltaTime;
-                    if (dstTravelled + moveStep > maxDistance)
-                    {
-                        moveStep = maxDistance - dstTravelled;
-                        isArrived = true;
-                    }
-                    dstTravelled += moveStep;
-                    transform.position = pathCreator.path.GetPointAtDistance(dstTravelled, EndOfPathInstruction.Stop);
-                }
-                else
-                {
-                    rb.velocity = Vector3.zero;
-                    if (isAttack)
-                    {
-                        if (pastAttackTime >= attackController.attackInterval)
-                        {
-                            Attack_march();
-                        }
-                    }
-                }
-                break;
+           
             default:
                 break;
         }
@@ -712,13 +575,6 @@ public class Enemy : MoveCharacter
             case CharacterState.Die:
                 isDie = false;
                 break;
-            case CharacterState.Climb:
-                if (!isOnTree)
-                {
-                    rb.useGravity = true;
-                    canNotShotDown = false;
-                }
-                break;
             default:
                 break;
         }
@@ -732,11 +588,9 @@ public class Enemy : MoveCharacter
                     ani.Play("idle", 0, 0);
                 }
                 rb.velocity = Vector3.zero;
-                //animalAni.SetInteger("state", (int)PlayerState.Idle);
                 break;
             case CharacterState.Run:
                 ani.Play("walk", 0, 0);
-                //animalAni.SetInteger("state", (int)PlayerState.Walk);
                 break;
             case CharacterState.Rush:
                 ani.Play("rush", 0, 0);
@@ -749,37 +603,6 @@ public class Enemy : MoveCharacter
                 dieKeepTime = totalDieKeepTime;
                 DropSouls();
                 break;
-            case CharacterState.Escape:
-                distanceToTower = distanceToTowerBase + Random.Range(-distanceToTowerDeviation, distanceToTowerDeviation);
-                distanceToEnemy = distanceToEnemyBase + Random.Range(-distanceToEnemyDeviation, distanceToEnemyDeviation);
-                ani.Play("walk", 0, 0);
-                stopEscapeTimer = Time.time;
-                Turn();
-                break;
-            case CharacterState.WaitForTank:
-                ani.Play("idle", 0, 0);
-                rb.velocity = Vector3.zero;
-                transform.rotation = Quaternion.identity;
-                break;
-            case CharacterState.Climb:
-                if (!isOnTree)
-                {
-                    isArrived = false;
-                    dstTravelled = 0f;
-                    targetPoint = Random.Range(0.6f, 1f);
-                    rb.useGravity = false;
-                    isOnTree = true;
-                    canNotShotDown = false;
-                }
-                break;
-            case CharacterState.HitStun:
-                canNotShotDown = true;
-                if (isOnTree)
-                {
-                    rb.useGravity = true;
-                    isOnTree = false;
-                }
-                break;
             default:
                 break;
         }
@@ -961,11 +784,6 @@ public class Enemy : MoveCharacter
                 break;
         }
     }
-
-    private bool CheckEscape()
-    {
-        return canEscape && !escapeTrigger.IsSafe(distanceToEnemy) && !escapeTrigger.IsInEnemyTower(distanceToTower);
-    }
     public void Attack_summon()
     {
         attackController.Attack_summon();

ActionTowerDefense/Assets/Scripts/Characters/Monkey.cs

@@ -0,0 +1,559 @@
+using System.Collections;
+using System.Collections.Generic;
+using Unity.VisualScripting;
+using UnityEngine;
+using PathCreation;
+using Sirenix.OdinInspector;
+
+public class Monkey : Enemy
+{
+    private string currentAnimation;
+    [Header("逃跑组件")]
+    public float escapeSpeed; //逃跑速度
+    public float distanceToTowerDeviation; //怪物逃跑靠近塔的距离偏差，防止怪物堆在一起
+    public float distanceToTowerBase; //怪物逃跑靠近塔的基础距离
+    public float distanceToEnemyDeviation; //怪物逃跑靠近坦克敌人的距离偏差，防止怪物堆在一起
+    public float distanceToEnemyBase; //怪物逃跑靠近坦克敌人的基础距离
+    private float distanceToTower;
+    private float distanceToEnemy;
+    [Header("攀爬组件")]
+    public float climbSpeed;
+    public PathCreator pathCreator;
+    private float dstTravelled;
+    private bool isReady = false;
+    private bool isArrived = false;
+    private float targetPoint;
+    private bool isOnTree = false;
+    private EscapeTrigger escapeTrigger;
+    public MonkeyState monkeyState = MonkeyState.None;
+
+    public override void Awake()
+    {
+        base.Awake();
+        searchTrigger.TryGetComponent<EscapeTrigger>(out escapeTrigger);
+        if (escapeTrigger == null) escapeTrigger = searchTrigger.AddComponent<EscapeTrigger>();
+    }
+
+    public void ChangeAnimation(string animation,float crossFade = 0.2f)
+    {
+        if(currentAnimation == animation) return;
+        currentAnimation = animation;
+        ani.CrossFade(currentAnimation, crossFade);
+    }
+
+    public override void ChangeState(CharacterState newState)
+    {
+        if (state == newState)
+        {
+            return;
+        }
+        ChangeMonkeyState(MonkeyState.None);
+        Debug.Log("从" + state + "切换到" + newState);
+        switch (state)
+        {
+            case CharacterState.Run:
+                rb.velocity = Vector3.zero;
+                break;
+            case CharacterState.Rush:
+                rb.velocity = Vector3.zero;
+                break;
+            case CharacterState.Rise:
+                if (!canFly)
+                {
+                    bodyCollider.SetActive(true);
+                }
+                break;
+            case CharacterState.Fall:
+                rb.velocity = Vector3.zero;
+                break;
+            case CharacterState.Attack:
+                attackController.ChooseAttack(curAttackID);
+                attackController.isAttackTriggerOn = false;
+                attackController.attackTrigger.gameObject.SetActive(false);
+                break;
+            case CharacterState.Die:
+                isDie = false;
+                break;
+            default:
+                break;
+        }
+        CharacterState oldState = state;
+        state = newState;
+        switch (newState)
+        {
+            case CharacterState.Idle:
+                if (!isConAttack || attackController.attackInterval > 0)
+                {
+                    //ani.Play("idle", 0, 0);
+                    ChangeAnimation("idle");
+                }
+                rb.velocity = Vector3.zero;
+                break;
+            case CharacterState.Run:
+                //ani.Play("walk", 0, 0);
+                ChangeAnimation("walk");
+                break;
+            case CharacterState.Rush:
+                //ani.Play("rush", 0, 0);
+                ChangeAnimation("rush");
+                break;
+            case CharacterState.Attack:
+                break;
+            case CharacterState.Die:
+                //ani.Play("die", 0, 0);
+                ChangeAnimation("die",0);
+                isDie = true;
+                dieKeepTime = totalDieKeepTime;
+                DropSouls();
+                break;
+            case CharacterState.HitStun:
+                canNotShotDown = true;
+                if (isOnTree)
+                {
+                    rb.useGravity = true;
+                    isOnTree = false;
+                }
+                break;
+            default:
+                break;
+        }
+    }
+
+    public void ChangeMonkeyState(MonkeyState newState)
+    {
+        if (monkeyState == newState)
+        {
+            return;
+        }
+        switch (monkeyState)
+        {
+            case MonkeyState.Climb:
+                if (!isOnTree)
+                {
+                    rb.useGravity = true;
+                    canNotShotDown = false;
+                }
+                break;
+        }
+        monkeyState = newState;
+        switch (newState)
+        {
+            case MonkeyState.None:
+                ChangeState(CharacterState.Idle);
+                break;
+            case MonkeyState.Escape:
+                distanceToTower = distanceToTowerBase + Random.Range(-distanceToTowerDeviation, distanceToTowerDeviation);
+                distanceToEnemy = distanceToEnemyBase + Random.Range(-distanceToEnemyDeviation, distanceToEnemyDeviation);
+                ChangeAnimation("walk");
+                Turn();
+                break;
+            case MonkeyState.WaitForTank:
+                ChangeAnimation("idle");
+                rb.velocity = Vector3.zero;
+                transform.rotation = Quaternion.identity;
+                break;
+            case MonkeyState.Climb:
+                if (!isOnTree)
+                {
+                    ChangeAnimation("clamp");
+                    isReady = false;
+                    isArrived = false;
+                    dstTravelled = 0f;
+                    targetPoint = Random.Range(0.6f, 1f);
+                    rb.useGravity = false;
+                    isOnTree = true;
+                    canNotShotDown = false;
+                }
+                break;
+        }
+    }
+
+    public override void FixedUpdate()
+    {
+        base.FixedUpdate();
+    }
+
+    public override void OnState()
+    {
+        if (state == CharacterState.None)
+        {
+            return;
+        }
+        //hurtKeepTime -= Time.deltaTime;
+        dieKeepTime -= Time.deltaTime;
+        invincibleTime -= Time.deltaTime;
+        pastAttackTime += Time.deltaTime;
+        Vector3 leftDir = GetMoveDir();
+        bool isAttack = GetAttack();
+        Vector3 velocity = rb.velocity;
+        Quaternion targetQt = Quaternion.Euler(Vector3.zero);
+        switch (monkeyState)
+        {
+            case MonkeyState.None:
+                switch (state)
+                {
+                    case CharacterState.Idle:
+                        if (isAdjustHeight == 1)
+                        {
+                            ChangeState(CharacterState.Rise);
+                            break;
+                        }
+                        else if (isAttack)
+                        {
+                            if (pastAttackTime >= attackController.attackInterval)
+                            {
+                                Attack_march();
+                            }
+                        }
+                        else
+                        {
+                            if (isOnTree && isArrived) return;
+                            if (!foot.TrigGround && !canFly)
+                            {
+                                if (rb.velocity.y > 0)
+                                {
+                                    ChangeState(CharacterState.Rise);
+                                    break;
+                                }
+                                else
+                                {
+                                    ChangeState(CharacterState.Fall);
+                                    break;
+                                }
+                            }
+                            if (leftDir.x > 0.3f || leftDir.x < -0.3f)
+                            {
+                                ChangeState(CharacterState.Run);
+                                break;
+                            }
+                            velocity.y = 0;
+                            if (!foot.haveGravity)
+                            {
+                                transform.position = new Vector3(transform.position.x, platformPosY, transform.position.z);
+                                targetQt = Quaternion.Euler(transform.rotation.eulerAngles.x, transform.rotation.eulerAngles.y, platformRotZ);
+                            }
+                            if (RotLerpTime < 1)
+                            {
+                                RotLerpTime += RotLerpSpeed * Time.deltaTime;
+                                transform.rotation = Quaternion.Lerp(transform.rotation, targetQt, RotLerpTime);
+                            }
+                            else
+                            {
+                                transform.rotation = targetQt;
+                            }
+                            rb.velocity = velocity;
+                        }
+                        break;
+                    case CharacterState.Run:
+                        if (isAttack)
+                        {
+                            if (pastAttackTime >= attackController.attackInterval)
+                            {
+                                Attack_march();
+                            }
+                            else
+                            {
+                                ChangeState(CharacterState.Idle);
+                            }
+                        }
+                        else
+                        {
+                            if (!foot.TrigGround && !canFly)
+                            {
+                                if (rb.velocity.y > 0)
+                                {
+                                    ChangeState(CharacterState.Rise);
+                                    break;
+                                }
+                                else
+                                {
+                                    ChangeState(CharacterState.Fall);
+                                    break;
+                                }
+                            }
+                            if (leftDir.x < 0.3f && leftDir.x > -0.3f)
+                            {
+                                ChangeState(CharacterState.Idle);
+                                break;
+                            }
+                            if (leftDir.x > 0.3f)
+                            {
+                                velocity.x = moveSpeed;
+                                if (bodyTrans.localScale.x > 0)
+                                {
+                                    Turn();
+                                }
+                            }
+                            else if (leftDir.x < -0.3f)
+                            {
+                                velocity.x = -moveSpeed;
+                                if (bodyTrans.localScale.x < 0)
+                                {
+                                    Turn();
+                                }
+                            }
+                            velocity.y = 0;
+                            if (!foot.haveGravity)
+                            {
+                                transform.position = new Vector3(transform.position.x, platformPosY, transform.position.z);
+                                targetQt = Quaternion.Euler(transform.rotation.eulerAngles.x, transform.rotation.eulerAngles.y, platformRotZ);
+                            }
+                            if (RotLerpTime < 1)
+                            {
+                                RotLerpTime += RotLerpSpeed * Time.deltaTime;
+                                transform.rotation = Quaternion.Lerp(transform.rotation, targetQt, RotLerpTime);
+                            }
+                            else
+                            {
+                                transform.rotation = targetQt;
+                            }
+                            rb.velocity = velocity;
+                            AdjustHeight();
+                        }
+                        break;
+                    case CharacterState.Rise:
+                        if (isAdjustHeight == 1)
+                        {
+                            AdjustHeight();
+                            if (!foot.haveGravity)
+                            {
+                                targetQt = Quaternion.Euler(transform.rotation.eulerAngles.x, transform.rotation.eulerAngles.y, platformRotZ);
+                            }
+                            if (RotLerpTime < 1)
+                            {
+                                RotLerpTime += RotLerpSpeed * Time.deltaTime;
+                                transform.rotation = Quaternion.Lerp(transform.rotation, targetQt, RotLerpTime);
+                            }
+                            else
+                            {
+                                transform.rotation = targetQt;
+                            }
+                        }
+                        else if (isAdjustHeight == 2)
+                        {
+                            ChangeState(CharacterState.Idle);
+                            isAdjustHeight = 0;
+                        }
+                        else
+                        {
+                            if (rb.velocity.y <= 0)
+                            {
+                                ChangeState(CharacterState.Fall);
+                                break;
+                            }
+                            rb.velocity += Vector3.up * extraRiseGravity * Time.deltaTime;
+                        }
+                        break;
+                    case CharacterState.Fall:
+                        if (foot.TrigGround || canFly)
+                        {
+                            ChangeState(CharacterState.Idle);
+                            break;
+                        }
+                        velocity.y += extraFallGravity * Time.deltaTime;
+                        if (leftDir.x > 0.3f)
+                        {
+                            velocity.x = moveSpeed;
+                            if (bodyTrans.localScale.x > 0)
+                            {
+                                Turn();
+                            }
+                        }
+                        else if (leftDir.x < -0.3f)
+                        {
+                            velocity.x = -moveSpeed;
+                            if (bodyTrans.localScale.x < 0)
+                            {
+                                Turn();
+                            }
+                        }
+
+                        rb.velocity = velocity;
+                        break;
+                    case CharacterState.Attack:
+                        attackController.JudgeTriggerOnOff();
+                        if (attackController.attackTime <= 0)
+                        {
+                            isAttack = GetAttack();
+                            if (isAttack)
+                            {
+                                isConAttack = true;
+                            }
+                            if (CheckEscape() && !isOnTree)
+                            {
+                                ChangeMonkeyState(MonkeyState.Escape);
+                                return;
+                            }
+                            Debug.Log("切换待机");
+                            ChangeState(CharacterState.Idle);
+                            break;
+                        }
+                        if (!foot.haveGravity)
+                        {
+                            targetQt = Quaternion.Euler(transform.rotation.eulerAngles.x, transform.rotation.eulerAngles.y, platformRotZ);
+                        }
+                        if (RotLerpTime < 1)
+                        {
+                            RotLerpTime += RotLerpSpeed * Time.deltaTime;
+                            transform.rotation = Quaternion.Lerp(transform.rotation, targetQt, RotLerpTime);
+                        }
+                        else
+                        {
+                            transform.rotation = targetQt;
+                        }
+                        break;
+                    case CharacterState.Die:
+                        if (dieKeepTime <= 0)
+                        {
+                            if (killer != null && killer.GetComponent<Demonic>())
+                            {
+                                SoldierType st = killer.GetComponent<Demonic>().soldierType;
+                                SoldierEXP.expInstance.AddEXP(st, (int)(exp * LevelSelect.EXPRatio + 0.5f));
+                            }
+                            if (dieEffect)
+                            {
+                                PoolManager.Instantiate(dieEffect, transform.position);
+                            }
+                            gameObject.SetActive(false);
+                            break;
+                        }
+                        break;
+                    case CharacterState.HitStun:
+                        hitFeedbackSystem.HitStunUpdate();
+                        break;
+                    case CharacterState.SpecialStatus_Float:
+                        attributeStatus.SpecialStateEffect(SpecialState.FloatState);
+                        break;
+                    case CharacterState.SpecialStatus_BlowUp:
+                        attributeStatus.SpecialStateEffect(SpecialState.BlownUp);
+                        break;
+                    case CharacterState.SpecialStatus_ShotDown:
+                        attributeStatus.SpecialStateEffect(SpecialState.ShotDown);
+                        break;
+                    case CharacterState.SpecialStatus_Weak:
+                        attributeStatus.SpecialStateEffect(SpecialState.Weak);
+                        break;
+                }
+                break;
+            case MonkeyState.Escape:
+                if (!foot.TrigGround && !canFly)
+                {
+                    if (rb.velocity.y > 0)
+                    {
+                        ChangeState(CharacterState.Rise);
+                        break;
+                    }
+                    else
+                    {
+                        ChangeState(CharacterState.Fall);
+                        break;
+                    }
+                }
+                velocity.x = -escapeSpeed;
+                if (bodyTrans.localScale.x < 0)
+                {
+                    Turn();
+                }
+                velocity.y = 0;
+                if (!foot.haveGravity)
+                {
+                    transform.position = new Vector3(transform.position.x, platformPosY, transform.position.z);
+                    targetQt = Quaternion.Euler(transform.rotation.eulerAngles.x, transform.rotation.eulerAngles.y, platformRotZ);
+                }
+                if (RotLerpTime < 1)
+                {
+                    RotLerpTime += RotLerpSpeed * Time.deltaTime;
+                    transform.rotation = Quaternion.Lerp(transform.rotation, targetQt, RotLerpTime);
+                }
+                else
+                {
+                    transform.rotation = targetQt;
+                }
+                rb.velocity = velocity;
+                AdjustHeight();
+                if (escapeTrigger.IsSafe(distanceToEnemy))
+                {
+                    ChangeState(CharacterState.Run);
+                }
+                else if (escapeTrigger.IsInEnemyTower(distanceToTower))
+                {
+                    ChangeMonkeyState(MonkeyState.WaitForTank);
+                }
+                break;
+            case MonkeyState.WaitForTank:
+                if (bodyTrans.localScale.x > 0)
+                {
+                    Turn();
+                }
+                if (escapeTrigger.IsSafe(distanceToEnemy))
+                {
+                    ChangeState(CharacterState.Run);
+                }
+                else if (isAttack)
+                {
+                    if (pastAttackTime >= attackController.attackInterval)
+                    {
+                        Attack_march();
+                    }
+                }
+                break;
+            case MonkeyState.Climb:
+                if (!isReady)
+                {
+                    float moveToStartSpeed = climbSpeed * Time.fixedDeltaTime;
+                    Vector3 startPosition = pathCreator.path.GetPoint(0);
+                    transform.position = Vector3.MoveTowards(transform.position, startPosition, moveToStartSpeed);
+                    if (Vector2.Distance(transform.position, startPosition) < 0.3f)
+                    {
+                        dstTravelled = 0;
+                        isReady = true;
+                    }
+                }
+                else if (!isArrived)
+                {
+                    float maxDistance = pathCreator.path.length * targetPoint;
+                    float moveStep = climbSpeed * Time.fixedDeltaTime;
+                    if (dstTravelled + moveStep > maxDistance)
+                    {
+                        moveStep = maxDistance - dstTravelled;
+                        isArrived = true;
+                        ChangeState(CharacterState.Idle);
+                    }
+                    dstTravelled += moveStep;
+                    transform.position = pathCreator.path.GetPointAtDistance(dstTravelled, EndOfPathInstruction.Stop);
+                }
+                //else
+                //{
+                //    rb.velocity = Vector3.zero;
+                //    if (isAttack)
+                //    {
+                //        if (pastAttackTime >= attackController.attackInterval)
+                //        {
+                //            Attack_march();
+                //        }
+                //    }
+                //}
+                break;
+        }
+    }
+
+    private bool CheckEscape()
+    {
+        return !escapeTrigger.IsSafe(distanceToEnemy) && !escapeTrigger.IsInEnemyTower(distanceToTower);
+    }
+
+    protected override void Start()
+    {
+        base.Start();
+        distanceToTower = distanceToTowerBase;
+        distanceToEnemy = distanceToEnemyBase;
+    }
+
+    public enum MonkeyState
+    {
+        None = 0,
+        Escape = 1, //正常状态
+        WaitForTank = 2, //寻找主角位置
+        Climb = 3,   //向主角方向冲刺中
+    }
+}

ActionTowerDefense/Assets/Scripts/Characters/Monkey.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: f618e99d71df88348bd4645872c17996
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ActionTowerDefense/Assets/Scripts/TreePath.cs

@@ -18,13 +18,9 @@ public class TreePath : MonoBehaviour
     {
         if (other.gameObject.layer == 8)
         {
-            Enemy enemy = other.GetComponentInParent<Enemy>();
-            //Debug.Log(enemy == null);
-            if (enemy.canClimb)
-            {
-                enemy.pathCreator = GetPath();
-                enemy.ChangeState(CharacterState.Climb);
-            }
+            Monkey enemy = other.GetComponentInParent<Monkey>();
+            enemy.pathCreator = GetPath();
+            enemy.ChangeMonkeyState(Monkey.MonkeyState.Climb);
         }
     }
 }