今天是一个3D平台跳跃游戏的笔记。
我们按照以下分类来对这个项目的代码进行学习：
核心游戏系统 (Core Game Systems)
核心游戏系统是IkunOdyssey项目的基础，负责所有游戏对象（如玩家、敌人、道具等）的通用行为和物理交互。它通过实体基础系统和游戏管理系统，为整个游戏提供了统一的物理、碰撞、状态管理和全局数据控制等功能，保证了游戏世界的有序运行和各模块的高效协作。
实体基础系统
实体基础系统为玩家、敌人等所有游戏对象提供统一的物理运动、碰撞检测和状态管理能力，是实现角色行为和交互的底层支撑。
物理移动系统
public virtual void Accelerate(Vector3 direction, float turningDrag, float acceleration, float topSpeed)
{
if (direction.sqrMagnitude > 0)
{
var speed = Vector3.Dot(direction, lateralVelocity);
var velocity = direction * speed;
var turningVelocity = lateralVelocity - velocity;
var turningDelta = turningDrag * turningDragMultiplier * Time.deltaTime;
var targetTopSpeed = topSpeed * topSpeedMultiplier;
if (lateralVelocity.magnitude < targetTopSpeed || speed < 0)
{
speed += acceleration * accelerationMultiplier * Time.deltaTime;
speed = Mathf.Clamp(speed, -targetTopSpeed, targetTopSpeed);
}
velocity = direction * speed;
turningVelocity = Vector3.MoveTowards(turningVelocity, Vector3.zero, turningDelta);
lateralVelocity = velocity + turningVelocity;
}
}
public virtual void Decelerate(float deceleration)
{
var delta = deceleration * decelerationMultiplier * Time.deltaTime;
lateralVelocity = Vector3.MoveTowards(lateralVelocity, Vector3.zero, delta);
}
public virtual void Gravity(float gravity)
{
if (!isGrounded)
{
verticalVelocity += Vector3.down * gravity * gravityMultiplier * Time.deltaTime;
}
}
public virtual void SlopeFactor(float upwardForce, float downwardForce)
{
if (!isGrounded || !OnSlopingGround()) return;
var factor = Vector3.Dot(Vector3.up, groundNormal);
var downwards = Vector3.Dot(localSlopeDirection, lateralVelocity) > 0;
var multiplier = downwards ? downwardForce : upwardForce;
var delta = factor * multiplier * Time.deltaTime;
lateralVelocity += localSlopeDirection * delta;
}这部分代码实现了实体的物理移动，包括加速、减速、重力和斜坡处理。Accelerate方法让实体根据输入方向平滑加速并支持转向，Decelerate方法让实体速度逐渐归零，Gravity方法在实体不在地面时持续施加重力，SlopeFactor方法则根据实体是否在斜坡上调整其速度，模拟上坡减速和下坡加速的效果。这些方法保证了实体在不同地形和状态下都能有自然的物理表现。
碰撞检测系统
public virtual bool CapsuleCast(Vector3 direction, float distance, int layer = Physics.DefaultRaycastLayers,
QueryTriggerInteraction queryTriggerInteraction = QueryTriggerInteraction.Ignore)
{
return CapsuleCast(direction, distance, out _, layer, queryTriggerInteraction);
}
public virtual bool CapsuleCast(Vector3 direction, float distance,
out RaycastHit hit, int layer = Physics.DefaultRaycastLayers,
QueryTriggerInteraction queryTriggerInteraction = QueryTriggerInteraction.Ignore)
{
var origin = position - direction * radius + center;
var offset = transform.up * (height * 0.5f - radius);
var top = origin + offset;
var bottom = origin - offset;
return Physics.CapsuleCast(top, bottom, radius, direction,
out hit, distance + radius, layer, queryTriggerInteraction);
}
public virtual bool SphereCast(Vector3 direction, float distance, int layer = Physics.DefaultRaycastLayers,
QueryTriggerInteraction queryTriggerInteraction = QueryTriggerInteraction.Ignore)
{
return SphereCast(direction, distance, out _, layer, queryTriggerInteraction);
}
public virtual bool SphereCast(Vector3 direction, float distance,
out RaycastHit hit, int layer = Physics.DefaultRaycastLayers,
QueryTriggerInteraction queryTriggerInteraction = QueryTriggerInteraction.Ignore)
{
var castDistance = Mathf.Abs(distance - radius);
return Physics.SphereCast(position, radius, direction,
out hit, castDistance, layer, queryTriggerInteraction);
}
public virtual int OverlapEntity(Collider[] result, float skinOffset = 0)
{
var contactOffset = skinOffset + controller.skinWidth + Physics.defaultContactOffset;
var overlapsRadius = radius + contactOffset;
var offset = (height + contactOffset) * 0.5f - overlapsRadius;
var top = position + Vector3.up * offset;
var bottom = position + Vector3.down * offset;
return Physics.OverlapCapsuleNonAlloc(top, bottom, overlapsRadius, result);
}实现了多种碰撞检测方式，包括胶囊体射线检测（CapsuleCast）、球体射线检测（SphereCast）和实体周围的重叠检测（OverlapEntity）。这些方法可以分别用于角色控制器的前方障碍检测、地面检测以及判断实体是否与其他物体发生接触，从而保证实体在游戏世界中能够正确地移动、落地和响应碰撞。
状态管理系统
public virtual void Change<TState>() where TState : EntityState<T>
{
var type = typeof(TState);
if (m_states.ContainsKey(type))
{
Change(m_states[type]);
}
}
public virtual void Change(EntityState<T> to)
{
if (to != null && Time.timeScale > 0)
{
if (current != null)
{
current.Exit(entity);
events.onExit.Invoke(current.GetType());
last = current;
}
current = to;
current.Enter(entity);
events.onEnter.Invoke(current.GetType());
events.onChange?.Invoke();
}
}
public virtual void Step()
{
if (current != null && Time.timeScale > 0)
{
current.Step(entity);
}
}实现了实体的状态管理功能。Change<TState>方法可以通过类型切换到指定的状态，Change(EntityState<T>)方法则切换到具体的状态实例，并自动调用状态的退出和进入方法，同时触发相关事件。Step方法则在每一帧调用当前状态的Step逻辑，实现状态的持续行为处理。通过这种方式，实体可以灵活地在不同状态间切换，实现如移动、跳跃、受伤等复杂行为的管理。
游戏管理
游戏管理系统负责全局数据的统一管理、关卡进度控制和存档功能，是游戏流程和数据安全的核心保障。
游戏主控制器
public class Game : Singleton<Game>
{
public UnityEvent<int> OnRetriesSet;
public UnityEvent OnSavingRequested;
public int initialRetries = 3;
public List<GameLevel> levels;
protected int m_retries;
protected int m_dataIndex;
protected DateTime m_createdAt;
protected DateTime m_updatedAt;
public int retries
{
get { return m_retries; }
set
{
m_retries = value;
OnRetriesSet?.Invoke(m_retries);
}
}
public static void LockCursor(bool value = true)
{
#if UNITY_STANDALONE || UNITY_WEBGL
Cursor.visible = value;
Cursor.lockState = value ? CursorLockMode.Locked : CursorLockMode.None;
#endif
}
public virtual void LoadState(int index, GameData data)
{
m_dataIndex = index;
m_retries = data.retries;
m_createdAt = DateTime.Parse(data.createdAt);
m_updatedAt = DateTime.Parse(data.updatedAt);
for (int i = 0; i < data.levels.Length; i++)
{
levels[i].LoadState(data.levels[i]);
}
}
public virtual LevelData[] LevelsData()
{
return levels.Select(level => level.ToData()).ToArray();
}
public virtual GameLevel GetCurrentLevel()
{
var scene = GameLoader.instance.currentScene;
return levels.Find((level) => level.scene == scene);
}
public virtual int GetCurrentLevelIndex()
{
var scene = GameLoader.instance.currentScene;
return levels.FindIndex((level) => level.scene == scene);
}
public virtual void RequestSaving()
{
GameSaver.instance.Save(ToData(), m_dataIndex);
OnSavingRequested?.Invoke();
}
public virtual void UnlockLevelBySceneName(string sceneName)
{
var level = levels.Find((level) => level.scene == sceneName);
if (level != null)
{
level.locked = false;
}
}
public virtual void UnlockNextLevel()
{
var index = GetCurrentLevelIndex() + 1;
if (index >= 0 && index < levels.Count)
{
levels[index].locked = false;
}
}
public virtual GameData ToData()
{
return new GameData()
{
retries = m_retries,
levels = LevelsData(),
createdAt = m_createdAt.ToString(),
updatedAt = DateTime.UtcNow.ToString()
};
}
protected override void Awake()
{
base.Awake();
retries = initialRetries;
DontDestroyOnLoad(gameObject);
}
}实现了游戏的全局管理功能。Game类采用单例模式，负责管理重试次数、关卡列表、数据加载与保存、关卡解锁等全局逻辑。它还通过事件机制与UI等其他系统解耦，保证了游戏流程的统一和数据的持久化。Awake方法确保Game对象在场景切换时不会被销毁，保证了全局数据的持续有效。
游戏数据管理
[Serializable]
public class GameData
{
public int retries;
public LevelData[] levels;
public string createdAt;
public string updatedAt;
public static GameData Create()
{
return new GameData()
{
retries = Game.instance.initialRetries,
createdAt = DateTime.UtcNow.ToString(),
updatedAt = DateTime.UtcNow.ToString(),
levels = Game.instance.levels.Select((level) =>
{
return new LevelData()
{
locked = level.locked
};
}).ToArray()
};
}
public virtual int TotalStars()
{
return levels.Aggregate(0, (acc, level) =>
{
var total = level.CollectedStars();
return acc + total;
});
}
public virtual int TotalCoins()
{
return levels.Aggregate(0, (acc, level) => acc + level.coins);
}
public virtual string ToJson()
{
return JsonUtility.ToJson(this);
}
public static GameData FromJson(string json)
{
return JsonUtility.FromJson<GameData>(json);
}
}定义了游戏的数据结构和序列化方法。GameData类用于存储玩家的重试次数、关卡进度、创建和更新时间等信息，并提供了JSON序列化和反序列化的方法，方便数据的保存和读取。它还支持统计所有关卡的星星和金币总数，便于全局进度统计和成就系统的实现。
存档系统
public class GameSaver : Singleton<GameSaver>
{
public enum Mode { Binary, JSON, PlayerPrefs }
public Mode mode = Mode.Binary;
public string fileName = "save";
public string binaryFileExtension = "data";
protected static readonly int TotalSlots = 5;
public virtual void Save(GameData data, int index)
{
switch (mode)
{
default:
case Mode.Binary:
SaveBinary(data, index);
break;
case Mode.JSON:
SaveJSON(data, index);
break;
case Mode.PlayerPrefs:
SavePlayerPrefs(data, index);
break;
}
}
public virtual GameData Load(int index)
{
switch (mode)
{
default:
case Mode.Binary:
return LoadBinary(index);
case Mode.JSON:
return LoadJSON(index);
case Mode.PlayerPrefs:
return LoadPlayerPrefs(index);
}
}
public virtual void Delete(int index)
{
switch (mode)
{
default:
case Mode.Binary:
case Mode.JSON:
DeleteFile(index);
break;
case Mode.PlayerPrefs:
DeletePlayerPrefs(index);
break;
}
}
public virtual GameData[] LoadList()
{
var list = new GameData[TotalSlots];
for (int i = 0; i < TotalSlots; i++)
{
var data = Load(i);
if (data != null)
{
list[i] = data;
}
}
return list;
}
// ... 省略具体的文件操作方法
}实现了多格式的存档系统，支持二进制、JSON和PlayerPrefs三种存档方式，并支持多存档槽位。Save、Load、Delete等方法根据当前模式选择不同的存储方式，LoadList方法可以一次性加载所有存档槽的数据，方便实现多存档和存档管理功能。这样可以保证玩家的游戏进度能够安全、灵活地保存和恢复。
玩家系统 (Player System)
玩家系统是游戏中最核心的交互模块，负责玩家角色的输入响应、属性管理、动画音效、状态切换等一系列行为控制，确保玩家在游戏世界中的一切操作都能被准确、流畅地反馈和表现出来。
玩家核心控制
玩家核心控制模块负责玩家角色的整体行为调度，包括输入管理、属性管理、生命值、状态切换等，是所有玩家行为的总入口。
玩家主控制器
public class Player : Entity<Player>
{
public PlayerEvents playerEvents;
public Transform pickableSlot;
public Transform skin;
public PlayerInputManager inputs { get; protected set; }
public PlayerStatsManager stats { get; protected set; }
public Health health { get; protected set; }
public bool onWater { get; protected set; }
public bool holding { get; protected set; }
public int jumpCounter { get; protected set; }
public int airSpinCounter { get; protected set; }
public int airDashCounter { get; protected set; }
public float lastDashTime { get; protected set; }
public Vector3 lastWallNormal { get; protected set; }
public Pole pole { get; protected set; }
public Collider water { get; protected set; }
public Pickable pickable { get; protected set; }
public virtual bool isAlive => !health.isEmpty;
public virtual bool canStandUp => !SphereCast(Vector3.up, originalHeight);
protected virtual void InitializeInputs() => inputs = GetComponent<PlayerInputManager>();
protected virtual void InitializeStats() => stats = GetComponent<PlayerStatsManager>();
protected virtual void InitializeHealth() => health = GetComponent<Health>();
protected virtual void InitializeTag() => tag = GameTags.Player;
protected override void Awake()
{
base.Awake();
InitializeInputs();
InitializeStats();
InitializeHealth();
InitializeTag();
}
}这段代码定义了玩家的主控制器Player类，继承自实体基础系统。它聚合了输入管理、属性管理、生命值、事件等多个组件，并在Awake阶段完成初始化。通过这些成员变量和初始化方法，玩家对象能够统一管理自身的输入、属性、生命状态和标签，成为所有玩家行为的核心调度中心。
玩家输入管理
public class PlayerInputManager : MonoBehaviour
{
public Vector2 moveInput { get; private set; }
public bool jumpPressed { get; private set; }
public bool dashPressed { get; private set; }
// ... 其他输入状态
void Update()
{
moveInput = new Vector2(Input.GetAxis("Horizontal"), Input.GetAxis("Vertical"));
jumpPressed = Input.GetButtonDown("Jump");
dashPressed = Input.GetButtonDown("Dash");
// ... 其他输入检测
}
}实现了玩家输入的采集和管理。PlayerInputManager会在每一帧读取键盘或手柄的输入状态，并将结果存储在对应的属性中，供玩家主控制器和状态机随时读取。这样可以实现输入与行为的解耦，方便后续扩展和多平台适配。
玩家属性管理
[CreateAssetMenu(fileName = "NewPlayerStats", menuName = "PLAYER TWO/Platformer Project/Player/New Player Stats")]
public class PlayerStats : EntityStats<PlayerStats>
{
public float acceleration = 13f;
public float deceleration = 28f;
public float topSpeed = 6f;
public int multiJumps = 1;
public float maxJumpHeight = 17f;
public float minJumpHeight = 10f;
public float dashForce = 25f;
public float dashDuration = 0.3f;
// ... 其他属性
}定义了玩家的属性配置，采用ScriptableObject方式，便于在Unity编辑器中可视化调整。属性包括加速度、最大速度、跳跃高度、冲刺参数等，所有与玩家能力相关的数值都集中在这里统一管理，方便平衡和调优。
玩家状态管理
public class PlayerStateManager : EntityStateManager<Player>
{
protected override List<EntityState<Player>> GetStateList()
{
return new List<EntityState<Player>>()
{
new IdlePlayerState(),
new MovePlayerState(),
new JumpPlayerState(),
new SwimPlayerState(),
// ... 其他状态
};
}
}实现了玩家的状态管理器。通过重写GetStateList方法，将所有玩家可能的状态（如Idle、Move、Jump、Swim等）注册到状态机中。这样，玩家可以根据输入和环境在不同状态间切换，实现复杂的行为逻辑和动画切换。
玩家功能模块
玩家功能模块包括动画、音效、粒子、相机等，负责将玩家的行为以视觉和听觉的方式反馈给玩家，提升游戏体验。
玩家动画控制
public class PlayerAnimator : MonoBehaviour
{
public Animator animator;
public void SetMoveSpeed(float speed)
{
animator.SetFloat("MoveSpeed", speed);
}
public void SetJump(bool isJumping)
{
animator.SetBool("IsJumping", isJumping);
}
// ... 其他动画参数设置
}通过Animator组件控制玩家的动画状态。根据玩家的移动速度、跳跃等行为，动态设置动画参数，实现角色动作与实际操作的同步。
玩家音效与粒子
public class PlayerAudio : MonoBehaviour
{
public AudioSource audioSource;
public AudioClip jumpClip;
public AudioClip dashClip;
public void PlayJump()
{
audioSource.PlayOneShot(jumpClip);
}
public void PlayDash()
{
audioSource.PlayOneShot(dashClip);
}
}负责播放玩家的音效反馈。每当玩家执行跳跃、冲刺等动作时，调用对应方法即可播放相应音效，增强操作的打击感和沉浸感。
敌人系统 (Enemy System)
敌人系统负责游戏中所有敌方单位的行为逻辑、属性管理、AI感知、攻击判定、动画音效等。它不仅让敌人具备基础的移动、攻击、受伤、死亡等能力，还支持复杂的AI状态切换、路径巡逻、与玩家互动等高级功能，是游戏挑战性和趣味性的关键来源。
敌人核心控制
敌人核心控制模块负责敌人对象的整体行为调度，包括属性管理、状态切换、AI感知、攻击判定等，是所有敌人行为的总入口。
public class Enemy : Entity<Enemy>
{
public EnemyEvents enemyEvents;
protected Player m_player;
public EnemyStatsManager stats { get; protected set; }
public WaypointManager waypoints { get; protected set; }
public Health health { get; protected set; }
public Player player { get; protected set; }
protected virtual void InitializeStatsManager() => stats = GetComponent<EnemyStatsManager>();
protected virtual void InitializeWaypointsManager() => waypoints = GetComponent<WaypointManager>();
protected virtual void InitializeHealth() => health = GetComponent<Health>();
protected virtual void InitializeTag() => tag = GameTags.Enemy;
protected override void Awake()
{
base.Awake();
InitializeTag();
InitializeStatsManager();
InitializeWaypointsManager();
InitializeHealth();
}
public override void ApplyDamage(int amount, Vector3 origin)
{
if (!health.isEmpty && !health.recovering)
{
health.Damage(amount);
enemyEvents.OnDamage?.Invoke();
if (health.isEmpty)
{
controller.enabled = false;
enemyEvents.OnDie?.Invoke();
}
}
}
public virtual void Revive()
{
if (!health.isEmpty) return;
health.Reset();
controller.enabled = true;
enemyEvents.OnRevive.Invoke();
}
protected override void OnUpdate()
{
HandleSight();
ContactAttack();
}
}定义了敌人的主控制器Enemy类，继承自实体基础系统。它聚合了属性管理、路径点管理、生命值、事件等多个组件，并在Awake阶段完成初始化。ApplyDamage方法处理敌人受伤和死亡，Revive方法实现复活，OnUpdate方法则每帧处理AI感知和攻击判定。通过这些成员变量和方法，敌人对象能够统一管理自身的属性、生命、AI和与玩家的互动。
敌人属性与状态管理
敌人属性配置
[CreateAssetMenu(fileName = "NewEnemyStats", menuName = "PLAYER TWO/Platformer Project/Enemy/New Enemy Stats")]
public class EnemyStats : EntityStats<EnemyStats>
{
public float acceleration = 10f;
public float deceleration = 20f;
public float topSpeed = 4f;
public float gravity = 30f;
public float rotationSpeed = 600f;
public bool canAttackOnContact = true;
public int contactDamage = 1;
public float contactPushBackForce = 5f;
public float spotRange = 10f;
public float viewRange = 15f;
// ... 其他属性
}这段代码定义了敌人的属性配置，采用ScriptableObject方式，便于在Unity编辑器中可视化调整。属性包括加速度、最大速度、重力、攻击参数、感知范围等，所有与敌人能力相关的数值都集中在这里统一管理，方便平衡和调优。
敌人属性管理器
public class EnemyStatsManager : EntityStatsManager<EnemyStats> {}通过泛型继承，直接复用实体属性管理器的功能，实现对EnemyStats的统一管理。
敌人状态管理
public class EnemyStateManager : EntityStateManager<Enemy>
{
protected override List<EntityState<Enemy>> GetStateList()
{
return new List<EntityState<Enemy>>()
{
new IdleEnemyState(),
new PatrolEnemyState(),
new ChaseEnemyState(),
new AttackEnemyState(),
new HurtEnemyState(),
new DieEnemyState(),
// ... 其他状态
};
}
}通过重写GetStateList方法，将所有敌人可能的状态（如Idle、Patrol、Chase、Attack、Hurt、Die等）注册到状态机中。这样，敌人可以根据AI逻辑和环境在不同状态间切换，实现复杂的行为逻辑和动画切换。
敌人AI与感知系统
视野与感知
protected virtual void HandleSight()
{
if (!player)
{
var overlaps = Physics.OverlapSphereNonAlloc(position, stats.current.spotRange, m_sightOverlaps);
for (int i = 0; i < overlaps; i++)
{
if (m_sightOverlaps[i].CompareTag(GameTags.Player))
{
if (m_sightOverlaps[i].TryGetComponent<Player>(out var player))
{
this.player = player;
enemyEvents.OnPlayerSpotted?.Invoke();
return;
}
}
}
}
else
{
var distance = Vector3.Distance(position, player.position);
if ((player.health.current == 0) || (distance > stats.current.viewRange))
{
player = null;
enemyEvents.OnPlayerScaped?.Invoke();
}
}
}实现了敌人的视野感知功能。HandleSight方法会在每一帧检测周围是否有玩家进入感知范围，如果发现玩家则触发“发现玩家”事件；如果玩家离开视野或死亡，则触发“玩家逃脱”事件。这样可以实现敌人对玩家的动态感知和追踪。
路径点与巡逻
public class WaypointManager : MonoBehaviour
{
public Transform[] waypoints;
public int currentIndex = 0;
public Transform GetCurrentWaypoint()
{
if (waypoints.Length == 0) return null;
return waypoints[currentIndex];
}
public void MoveToNextWaypoint()
{
if (waypoints.Length == 0) return;
currentIndex = (currentIndex + 1) % waypoints.Length;
}
}实现了敌人的路径点巡逻功能。WaypointManager管理一组巡逻点，敌人可以依次移动到每个点，实现循环巡逻。通过GetCurrentWaypoint和MoveToNextWaypoint方法，敌人AI可以灵活地控制巡逻路线。
敌人攻击与交互
public virtual void ContactAttack()
{
if (stats.current.canAttackOnContact)
{
var overlaps = OverlapEntity(m_contactAttackOverlaps, stats.current.contactOffset);
for (int i = 0; i < overlaps; i++)
{
if (m_contactAttackOverlaps[i].CompareTag(GameTags.Player) &&
m_contactAttackOverlaps[i].TryGetComponent<Player>(out var player))
{
var stepping = controller.bounds.max + Vector3.down * stats.current.contactSteppingTolerance;
if (!player.IsPointUnderStep(stepping))
{
if (stats.current.contactPushback)
{
lateralVelocity = -transform.forward * stats.current.contactPushBackForce;
}
player.ApplyDamage(stats.current.contactDamage, transform.position);
enemyEvents.OnPlayerContact?.Invoke();
}
}
}
}
}实现了敌人的接触攻击判定，ContactAttack方法会检测敌人周围是否有玩家，如果有则对玩家造成伤害，并根据配置决定是否将敌人自身击退。这样可以实现敌人与玩家的近战碰撞和伤害判定。
敌人动画与音效
动画控制
public class EnemyAnimator : MonoBehaviour
{
public Animator animator;
public void SetMoveSpeed(float speed)
{
animator.SetFloat("MoveSpeed", speed);
}
public void SetAttack(bool isAttacking)
{
animator.SetBool("IsAttacking", isAttacking);
}
// ... 其他动画参数设置
}通过Animator组件控制敌人的动画状态。根据敌人的移动速度、攻击等行为，动态设置动画参数，实现角色动作与实际AI行为的同步。
音效反馈
public class EnemyAudio : MonoBehaviour
{
public AudioSource audioSource;
public AudioClip attackClip;
public AudioClip hurtClip;
public void PlayAttack()
{
audioSource.PlayOneShot(attackClip);
}
public void PlayHurt()
{
audioSource.PlayOneShot(hurtClip);
}
}播放敌人的音效反馈，每当敌人执行攻击、受伤等动作时，调用对应方法即可播放相应音效，增强敌人的存在感和打击感。
敌人事件系统
[Serializable]
public class EnemyEvents
{
public UnityEvent OnDamage;
public UnityEvent OnDie;
public UnityEvent OnRevive;
public UnityEvent OnPlayerSpotted;
public UnityEvent OnPlayerScaped;
public UnityEvent OnPlayerContact;
}定义了敌人的事件系统，通过UnityEvent，敌人可以在受伤、死亡、复活、发现玩家、玩家逃脱、接触玩家等关键时刻触发事件，方便与UI、音效、特效等其他系统解耦联动。
关卡系统 (Level System)
关卡系统负责游戏中每一关的流程控制、数据管理、评分统计、重生与完成判定等，是游戏内容组织、进度推进和挑战反馈的核心模块。它不仅管理关卡的启动、暂停、重生、完成等流程，还负责关卡内的分数、星星、金币等收集与统计，确保玩家的游戏体验连贯且富有成就感。
关卡核心管理
关卡核心管理模块负责关卡的整体生命周期，包括关卡的初始化、暂停、重生、完成等，是所有关卡行为的总入口。
关卡主控制器
public class GameLevel : MonoBehaviour
{
public string scene;
public bool locked = true;
public float time;
public int coins;
public bool[] stars = new bool[3];
public void LoadState(LevelData data)
{
locked = data.locked;
time = data.time;
coins = data.coins;
stars = (bool[])data.stars.Clone();
}
public LevelData ToData()
{
return new LevelData
{
locked = this.locked,
time = this.time,
coins = this.coins,
stars = (bool[])this.stars.Clone()
};
}
}定义了关卡的主控制器GameLevel类，负责记录关卡的场景名、解锁状态、最佳时间、金币数和星星收集情况。LoadState和ToData方法用于关卡数据的加载和保存，方便与全局存档系统对接，实现关卡进度的持久化。
关卡数据结构
[Serializable]
public class LevelData
{
public bool locked;
public float time;
public int coins;
public bool[] stars = new bool[3];
public int CollectedStars()
{
int count = 0;
foreach (var s in stars)
if (s) count++;
return count;
}
}定义了关卡的数据结构LevelData，包含解锁状态、最佳时间、金币数和星星收集情况，并提供了统计已收集星星数量的方法。该结构体用于关卡数据的存档、加载和统计。
关卡流程控制
关卡启动与暂停
public class LevelStarter : MonoBehaviour
{
void Start()
{
// 初始化关卡相关内容
// 比如重置分数、计时、玩家位置等
}
}
public class LevelPauser : MonoBehaviour
{
public void Pause()
{
Time.timeScale = 0;
}
public void Resume()
{
Time.timeScale = 1;
}
}实现了关卡的启动和暂停功能，LevelStarter在关卡开始时初始化相关内容，LevelPauser则通过修改Time.timeScale来实现暂停和恢复，保证玩家可以随时中断和继续游戏。
关卡重生与完成
public class LevelRespawner : MonoBehaviour
{
public Transform respawnPoint;
public Player player;
public void Respawn()
{
player.transform.position = respawnPoint.position;
player.Respawn();
}
}
public class LevelFinisher : MonoBehaviour
{
public void FinishLevel()
{
// 统计分数、保存进度、切换场景等
LevelScore.instance.Consolidate();
Game.instance.UnlockNextLevel();
// ... 其他完成关卡的逻辑
}
}实现了关卡的重生和完成判定，LevelRespawner负责将玩家重置到重生点并恢复状态，LevelFinisher则在关卡完成时统计分数、保存进度并解锁下一关，确保关卡流程的完整性和连贯性。
关卡评分与统计
public class LevelScore : Singleton<LevelScore>
{
public UnityEvent<int> OnCoinsSet;
public UnityEvent<bool[]> OnStarsSet;
public UnityEvent OnScoreLoaded;
public int coins { get; set; }
public bool[] stars { get; private set; }
public float time { get; private set; }
public bool stopTime { get; set; } = true;
public virtual void Reset()
{
time = 0;
coins = 0;
// stars初始化
}
public virtual void CollectStar(int index)
{
stars[index] = true;
OnStarsSet?.Invoke(stars);
}
public virtual void Consolidate()
{
// 更新关卡最佳成绩、保存数据
// ...
Game.instance.RequestSaving();
}
void Update()
{
if (!stopTime)
{
time += Time.deltaTime;
}
}
}这段代码实现了关卡的评分系统。LevelScore负责记录和统计关卡内的金币、星星、用时等数据，并通过事件通知UI等系统更新显示。CollectStar方法用于收集星星，Consolidate方法用于关卡完成时保存成绩和进度，Update方法则负责计时。
关卡UI与反馈
public class HUD : MonoBehaviour
{
public Text retries;
public Text coins;
public Text health;
public Text timer;
public Image[] starsImages;
protected Game m_game;
protected LevelScore m_score;
protected Player m_player;
public virtual void Refresh()
{
// 刷新UI显示
coins.text = m_score.coins.ToString("000");
retries.text = m_game.retries.ToString("00");
health.text = m_player.health.current.ToString("0");
// 星星和计时等
}
void Awake()
{
m_game = Game.instance;
m_score = LevelScore.instance;
m_player = FindObjectOfType<Player>();
// 监听事件，自动刷新
}
void Update()
{
// 实时更新计时器
}
}实现了关卡内的HUD显示，HUD负责将金币、重试次数、生命值、计时器、星星等信息实时显示在屏幕上，并通过事件机制与评分系统、游戏管理系统联动，保证UI信息的实时性和准确性。
关卡事件与数据交互
关卡系统通过GameLevel、LevelData、LevelScore等类与全局的GameData、Game等系统进行数据交互，实现关卡进度的保存、加载、统计和解锁。每当关卡完成、分数更新、星星收集等事件发生时，都会通过Consolidate、ToData等方法将数据同步到全局存档，保证玩家的游戏进度不会丢失。
Consolidate（合并/整合）方法用于在关卡完成时，将本次游戏过程中获得的分数、星星、用时等数据，合并到当前关卡的GameLevel对象中，并触发全局存档。它确保如果玩家本次表现比历史最好成绩更好，就会更新关卡的最佳记录。
public virtual void Consolidate()
{
if (m_level != null)
{
if (m_level.time == 0 || time < m_level.time)
{
m_level.time = time;
}
if (coins > m_level.coins)
{
m_level.coins = coins;
}
m_level.stars = (bool[])stars.Clone();
m_game.RequestSaving();
}
}- 如果本次用时比历史最佳更短，则更新最佳用时。
- 如果本次金币数比历史更多，则更新金币数。
- 星星收集情况也会被更新。
- 最后调用m_game.RequestSaving()，将最新数据保存到全局存档。
ToData方法的作用是将当前对象（如关卡、全局游戏）的运行时状态，转换为可序列化的数据结构（如LevelData、GameData），以便进行存档、网络传输或数据统计。
public LevelData ToData()
{
return new LevelData
{
locked = this.locked,
time = this.time,
coins = this.coins,
stars = (bool[])this.stars.Clone()
};
}将GameLevel对象的状态（解锁、时间、金币、星星）转换为LevelData结构，便于存档和数据传递。
用户界面系统 (UI System)
UI系统负责游戏中所有用户界面元素的显示与交互，包括游戏内HUD、关卡选择、存档管理、动画反馈等。它不仅为玩家提供实时的游戏信息（如分数、生命、星星、计时等），还承担着菜单导航、存档操作、关卡切换等重要功能，是玩家与游戏世界沟通的桥梁。
HUD（游戏内信息显示）
HUD（Head-Up Display）是游戏过程中最常见的UI，负责实时显示玩家的分数、生命、金币、星星、计时等关键信息。
public class HUD : MonoBehaviour
{
public string retriesFormat = "00";
public string coinsFormat = "000";
public string healthFormat = "0";
public Text retries;
public Text coins;
public Text health;
public Text timer;
public Image[] starsImages;
protected Game m_game;
protected LevelScore m_score;
protected Player m_player;
protected float timerStep;
protected static float timerRefreshRate = .1f;
protected virtual void UpdateCoins(int value)
{
coins.text = value.ToString(coinsFormat);
}
protected virtual void UpdateRetries(int value)
{
retries.text = value.ToString(retriesFormat);
}
protected virtual void UpdateHealth()
{
health.text = m_player.health.current.ToString(healthFormat);
}
protected virtual void UpdateStars(bool[] value)
{
for (int i = 0; i < starsImages.Length; i++)
{
starsImages[i].enabled = value[i];
}
}
protected virtual void UpdateTimer()
{
timerStep += Time.deltaTime;
if (timerStep >= timerRefreshRate)
{
timer.text = GameLevel.FormattedTime(m_score.time);
timerStep = 0;
}
}
public virtual void Refresh()
{
UpdateCoins(m_score.coins);
UpdateRetries(m_game.retries);
UpdateHealth();
UpdateStars(m_score.stars);
}
protected virtual void Awake()
{
m_game = Game.instance;
m_score = LevelScore.instance;
m_player = FindObjectOfType<Player>();
m_score.OnScoreLoaded.AddListener(() =>
{
m_score.OnCoinsSet.AddListener(UpdateCoins);
m_score.OnStarsSet.AddListener(UpdateStars);
m_game.OnRetriesSet.AddListener(UpdateRetries);
m_player.health.onChange.AddListener(UpdateHealth);
Refresh();
});
}
protected virtual void Update() => UpdateTimer();
}实现了HUD的全部核心功能。它通过监听分数、星星、重试次数、生命值等事件，实时刷新UI显示，并在Update中定时刷新计时器。Awake方法中完成了所有依赖对象的获取和事件绑定，Refresh方法则可手动强制刷新所有UI元素，保证信息的准确性和实时性。
关卡选择与存档管理UI
关卡卡片与关卡列表
public class UILevelCard : MonoBehaviour
{
public Text levelName;
public Image[] stars;
public Button playButton;
public void SetData(LevelData data)
{
levelName.text = "Level " + (data.levelIndex + 1);
for (int i = 0; i < stars.Length; i++)
{
stars[i].enabled = data.stars != null && i < data.stars.Length && data.stars[i];
}
playButton.interactable = !data.locked;
}
}实现了关卡选择界面中每个关卡卡片的显示。SetData方法根据LevelData设置关卡名称、星星收集情况和按钮可用状态，方便玩家直观了解每一关的进度和成就。
存档卡片与存档列表
public class UISaveCard : MonoBehaviour
{
public Text saveName;
public Text progress;
public Button loadButton;
public Button deleteButton;
public void SetData(GameData data, int slotIndex)
{
saveName.text = $"存档{slotIndex + 1}";
progress.text = $"星星：{data.TotalStars()} 金币：{data.TotalCoins()}";
loadButton.interactable = true;
deleteButton.interactable = true;
}
}实现了存档管理界面中每个存档卡片的显示。SetData方法根据GameData设置存档名称和进度信息，并控制按钮的可用性，方便玩家管理多个存档。
UI动画与交互辅助
UI动画控制
public class UIAnimator : MonoBehaviour
{
public Animator animator;
public void PlayShow()
{
animator.SetTrigger("Show");
}
public void PlayHide()
{
animator.SetTrigger("Hide");
}
}通过Animator组件控制UI的显示和隐藏动画。PlayShow和PlayHide方法分别触发不同的动画状态，提升UI的动态表现力和用户体验。
UI焦点与自动滚动
public class UIFocusKeeper : MonoBehaviour
{
public Selectable defaultSelectable;
void OnEnable()
{
if (defaultSelectable != null)
defaultSelectable.Select();
}
}保证UI界面激活时自动聚焦到指定的按钮或输入框，提升键盘/手柄操作的友好性。
事件系统 (Event System)
事件系统是游戏各个模块之间解耦通信的桥梁。它通过事件发布与监听机制，让玩家、敌人、关卡、UI等系统能够在关键时刻（如受伤、死亡、分数变化、关卡完成等）互相通知和响应，极大提升了代码的灵活性、可维护性和扩展性。
事件定义与基础结构
[Serializable]
public class PlayerEvent : UnityEvent<Player> {}定义了一个带有Player参数的UnityEvent，方便在玩家相关的事件（如受伤、死亡、复活等）中传递玩家对象本身，实现更灵活的事件响应。
[Serializable]
public class EnemyEvents
{
public UnityEvent OnDamage;
public UnityEvent OnDie;
public UnityEvent OnRevive;
public UnityEvent OnPlayerSpotted;
public UnityEvent OnPlayerScaped;
public UnityEvent OnPlayerContact;
}敌人相关的所有事件，包括受伤、死亡、复活、发现玩家、玩家逃脱、接触玩家等。每个事件都可以在Inspector中绑定多个响应函数，实现灵活的事件驱动。
[Serializable]
public class EntityEvents : UnityEvent {}定义了实体通用事件，适用于所有继承自Entity的对象，便于统一管理和扩展。
事件触发与监听
事件触发
// 以玩家受伤为例（Player.cs）
public override void ApplyDamage(int amount, Vector3 origin)
{
if (!health.isEmpty && !health.recovering)
{
health.Damage(amount);
playerEvents.OnHurt?.Invoke();
if (health.isEmpty)
{
playerEvents.OnDie?.Invoke();
}
}
}在玩家受到伤害时，先减少生命值，然后触发OnHurt事件。如果生命值归零，则触发OnDie事件。这样可以让UI、音效、动画等系统及时响应玩家受伤和死亡。
// 以敌人受伤为例（Enemy.cs）
public override void ApplyDamage(int amount, Vector3 origin)
{
if (!health.isEmpty && !health.recovering)
{
health.Damage(amount);
enemyEvents.OnDamage?.Invoke();
if (health.isEmpty)
{
controller.enabled = false;
enemyEvents.OnDie?.Invoke();
}
}
}在敌人受到伤害时，先减少生命值，然后触发OnDamage事件。如果生命值归零，则触发OnDie事件。这样可以让特效、音效、分数统计等系统及时响应敌人受伤和死亡。
事件监听
// 以UI监听玩家生命变化为例（HUD.cs）
protected virtual void Awake()
{
m_game = Game.instance;
m_score = LevelScore.instance;
m_player = FindObjectOfType<Player>();
m_player.health.onChange.AddListener(UpdateHealth);
// 其他事件监听...
}在HUD初始化时，监听玩家生命值变化事件，每当生命值变化时自动刷新UI显示，保证信息的实时性。
// 以关卡分数监听金币变化为例（LevelScore.cs）
public virtual int coins
{
get { return m_coins; }
set
{
m_coins = value;
OnCoinsSet?.Invoke(m_coins);
}
}在金币数量变化时，自动触发OnCoinsSet事件，通知所有监听者（如HUD）及时更新显示。
工具和辅助系统 (Tools & Utilities)
工具与辅助系统为项目开发和运行提供了各种便捷功能，包括类型名称工具、编辑器扩展、路径点管理、接口定义等。这些工具类和辅助脚本虽然不直接参与游戏核心玩法，但极大提升了开发效率、代码复用性和项目的可维护性。
类型名称工具
public static class ClassTypeName
{
public static string Get<T>()
{
return typeof(T).Name;
}
}实现了一个静态工具类，用于获取任意类型的类名字符串。通过泛型方法Get<T>()，可以方便地在日志、调试、反射等场景下获取类型名称，提升代码的可读性和调试效率。
编辑器扩展
#if UNITY_EDITOR
using UnityEditor;
using UnityEngine;
public class ExampleEditorTool
{
[MenuItem("Tools/Example/Print Hello")]
public static void PrintHello()
{
Debug.Log("Hello from Editor Tool!");
}
}
#endif这段代码演示了如何通过Unity编辑器扩展自定义菜单项。开发者可以在Unity菜单栏中添加自定义工具，提升开发效率，比如批量操作、自动化处理等。
路径点与导航辅助
public class WaypointManager : MonoBehaviour
{
public Transform[] waypoints;
public int currentIndex = 0;
public Transform GetCurrentWaypoint()
{
if (waypoints.Length == 0) return null;
return waypoints[currentIndex];
}
public void MoveToNextWaypoint()
{
if (waypoints.Length == 0) return;
currentIndex = (currentIndex + 1) % waypoints.Length;
}
}实现了路径点管理功能，常用于敌人巡逻、NPC移动等场景。WaypointManager维护一组路径点，支持获取当前路径点和切换到下一个路径点，方便AI和导航系统的实现。
接口与事件辅助
public interface IEntityContact
{
void OnEntityContact(Entity entity);
}定义了一个实体接触接口。实现该接口的组件可以在与其他实体发生接触时被自动调用，实现如机关触发、拾取、特殊交互等功能，提升系统的扩展性和灵活性。
游戏标签和配置 (Game Configuration)
游戏标签和配置系统为项目提供了统一的标签定义、全局常量、Layer/Tag管理以及项目级的参数配置。它不仅方便代码中对不同类型对象的快速识别和分组，还为后续的物理碰撞、事件判定、关卡管理等提供了基础支撑，是保证项目规范性和可维护性的关键部分。
游戏标签定义
public static class GameTags
{
public const string Player = "Player";
public const string Enemy = "Enemy";
public const string Platform = "Platform";
public const string InteractiveRail = "InteractiveRail";
// ... 其他标签
}这段代码定义了一个静态类GameTags，集中管理了项目中所有用到的Tag字符串常量。这样做可以避免在代码中硬编码字符串，减少拼写错误，提高代码的可读性和可维护性。比如在碰撞检测、查找对象、事件判定等场景下，直接用GameTags.Player等常量即可。
Layer/Tag 配置与使用
// 检查碰撞体是否为玩家
if (other.CompareTag(GameTags.Player))
{
// 玩家相关逻辑
}这段代码展示了如何在实际开发中使用标签常量进行对象类型判断。通过CompareTag方法结合GameTags常量，可以高效且安全地判断对象类型，便于实现不同对象的专属逻辑。
项目全局配置
在Unity项目中，ProjectSettings/目录下包含了诸如TagManager.asset、InputManager.asset、Physics2DSettings.asset等全局配置文件。这些文件通过Unity编辑器进行管理，决定了项目的输入映射、物理参数、标签和Layer等全局行为。
示例说明：
- TagManager.asset：管理所有Tag和Layer的定义，保证代码和编辑器中的标签一致。
- InputManager.asset：配置所有输入轴和按键映射，便于多平台适配。
- Physics2DSettings.asset/PhysicsSettings.asset：配置物理引擎参数，如重力、碰撞层、物理步长等。