yeahweregames/UnityTowerDefense
3
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

We've got enemies and movement!!

Browse source
This commit is contained in:
Matt F 2026-05-12 22:18:23 -07:00
parent 42ee0bf65d
commit 3287e8ea43
26 changed files with 1409 additions and 161 deletions
Download patch file Download diff file Expand all files Collapse all files

225
Assets/_Project/Scripts/Gameplay/EnemyMovement.cs Normal file
View file

@ -0,0 +1,225 @@
// Assets/_Project/Scripts/Gameplay/EnemyMovement.cs
using System.Collections.Generic;
using Unity.Netcode;
using UnityEngine;
using TD.Core;
using TD.Levels;
namespace TD.Gameplay
{
/// <summary>
/// Server-authoritative enemy movement along a dynamically computed A* path.
/// </summary>
/// <remarks>
/// <b>Initialization:</b> Call <see cref="InitializeServer"/> after <c>Instantiate</c>
/// and before <c>NetworkObject.Spawn()</c>. Provides the base move speed (from
/// <see cref="EnemyDefinition.MoveSpeed"/>) and the tile the enemy spawned on.
///
/// <b>Path lifecycle:</b>
/// <list type="bullet">
/// <item><see cref="OnNetworkSpawn"/> (server): queries <see cref="PathfindingService"/>
/// and stores the tile waypoint list.</item>
/// <item>Each frame: moves toward the world center of <c>remainingPath[0]</c>.
/// When within snap distance, pops the waypoint and checks for zone transitions.</item>
/// <item>When <see cref="PathfindingService.OnPathsInvalidated"/> fires (tower placed /
/// sold), <see cref="RecomputePath"/> reruns A* from the current tile.</item>
/// <item>When <c>remainingPath</c> is empty after a pop, the enemy has reached the
/// goal — <see cref="OnReachedGoal"/> fires and the enemy is despawned.</item>
/// </list>
///
/// <b>Zone leak tracking:</b> Each time a waypoint is popped, <see cref="LevelLoader.GetOwner"/>
/// is compared against <c>currentZone</c>. A change means the enemy has crossed a zone
/// boundary. <see cref="OnZoneLeaked"/> fires with the zone being LEFT so <c>WaveManager</c>
/// can debit the correct player's life pool.
///
/// <b>Speed:</b> Effective speed = <c>moveSpeed * EnemyStatus.GetSpeedMultiplier()</c>.
/// <c>EnemyStatus</c> replicates the multiplier as a NetworkVariable so movement looks
/// correct on all peers.
///
/// <b>Movement replication:</b> Requires a <c>NetworkTransform</c> on the prefab.
/// Position is written by the server; <c>NetworkTransform</c> interpolates on clients.
/// </remarks>
[RequireComponent(typeof(NetworkObject))]
[RequireComponent(typeof(EnemyHealth))]
[RequireComponent(typeof(EnemyStatus))]
public class EnemyMovement : NetworkBehaviour
{
// Snap threshold in world units. When sqrMagnitude to the waypoint center
// drops below this, we count the tile as reached and pop it.
private const float WaypointSnapSq = 0.04f; // 0.2 world units
// ----- Pre-spawn init (server-local) ----------------------------------
private float pendingMoveSpeed;
private Vector2Int pendingSpawnerTile;
private bool hasPendingInit;
// ----- Server-local runtime state -------------------------------------
private float moveSpeed;
private List<Vector2Int> remainingPath = new List<Vector2Int>();
private PlayerSlot currentZone = PlayerSlot.None;
private EnemyStatus status;
// ----- Events ---------------------------------------------------------
/// <summary>
/// Fired on the server when this enemy crosses from one player zone into another
/// (or from a neutral zone into a player zone). The argument is the zone being
/// LEFT — the zone that should be debited a life.
/// <c>WaveManager</c> subscribes to deduct from the correct player's life pool.
/// </summary>
public event System.Action<PlayerSlot> OnZoneLeaked;
/// <summary>
/// Fired on the server when the enemy reaches the goal tile.
/// Carries this component and the enemy's <see cref="EnemyHealth.LivesCost"/>
/// so <c>WaveManager</c> can deduct the right number of lives in one call.
/// The NetworkObject is despawned immediately after subscribers return.
/// </summary>
public event System.Action<EnemyMovement, int> OnReachedGoal;
// ----- Server-only pre-spawn init -------------------------------------
/// <summary>
/// Called by <c>WaveManager</c> on the server after <c>Instantiate</c> and
/// before <c>NetworkObject.Spawn()</c>. <paramref name="speed"/> comes from
/// <see cref="EnemyDefinition.MoveSpeed"/>; <paramref name="spawnerTile"/> is
/// the tile the enemy spawns on (used as the A* start node).
/// </summary>
public void InitializeServer(float speed, Vector2Int spawnerTile)
{
pendingMoveSpeed = speed;
pendingSpawnerTile = spawnerTile;
hasPendingInit = true;
}
// ----- NGO lifecycle --------------------------------------------------
public override void OnNetworkSpawn()
{
status = GetComponent<EnemyStatus>();
if (!IsServer) return;
if (!hasPendingInit)
{
Debug.LogError("[EnemyMovement] OnNetworkSpawn reached without InitializeServer " +
"having been called. Enemy will not move.");
return;
}
moveSpeed = pendingMoveSpeed;
// Resolve starting zone from the spawner tile.
var loader = LevelLoader.Instance;
if (loader != null)
currentZone = loader.GetOwner(pendingSpawnerTile);
// Compute the initial path from the spawn tile to the nearest goal.
ComputeAndStorePath(pendingSpawnerTile);
// Recompute when a tower is placed or sold.
if (PathfindingService.Instance != null)
PathfindingService.Instance.OnPathsInvalidated += RecomputePath;
}
public override void OnNetworkDespawn()
{
if (PathfindingService.Instance != null)
PathfindingService.Instance.OnPathsInvalidated -= RecomputePath;
}
// ----- Server update --------------------------------------------------
private void Update()
{
if (!IsServer) return;
if (remainingPath.Count == 0) return;
float effectiveSpeed = moveSpeed * (status != null ? status.GetSpeedMultiplier() : 1f);
Vector3 targetWorld = GridCoordinates.GridToWorld(remainingPath[0]);
Vector3 toTarget = targetWorld - transform.position;
if (toTarget.sqrMagnitude <= WaypointSnapSq)
{
// Snap to the tile center then handle the waypoint transition.
transform.position = targetWorld;
AdvanceWaypoint();
}
else
{
transform.position += toTarget.normalized * (effectiveSpeed * Time.deltaTime);
// Face the direction of travel.
if (toTarget.sqrMagnitude > 0.0001f)
transform.rotation = Quaternion.LookRotation(toTarget);
}
}
// ----- Path management ------------------------------------------------
private void AdvanceWaypoint()
{
Vector2Int arrivedTile = remainingPath[0];
remainingPath.RemoveAt(0);
CheckZoneTransition(arrivedTile);
if (remainingPath.Count == 0)
HandleGoalReached();
}
private void CheckZoneTransition(Vector2Int tile)
{
var loader = LevelLoader.Instance;
if (loader == null) return;
PlayerSlot newZone = loader.GetOwner(tile);
if (newZone == currentZone) return;
// The enemy is leaving currentZone — debit that player's life pool.
if (currentZone != PlayerSlot.None)
OnZoneLeaked?.Invoke(currentZone);
currentZone = newZone;
}
private void HandleGoalReached()
{
var health = GetComponent<EnemyHealth>();
int livesCost = health != null ? health.LivesCost : 1;
OnReachedGoal?.Invoke(this, livesCost);
NetworkObject.Despawn();
}
// ----- Path invalidation ----------------------------------------------
// Called on server when LevelLoader.OnWalkabilityChanged fires (tower placed/sold).
private void RecomputePath()
{
if (!IsServer) return;
// Recompute from the enemy's current tile position.
Vector2Int currentTile = GridCoordinates.WorldToGrid(transform.position);
ComputeAndStorePath(currentTile);
}
private void ComputeAndStorePath(Vector2Int fromTile)
{
var service = PathfindingService.Instance;
if (service == null)
{
Debug.LogWarning("[EnemyMovement] PathfindingService not found. Enemy will not move.");
return;
}
remainingPath = service.ComputePath(fromTile);
if (remainingPath.Count == 0)
Debug.LogWarning($"[EnemyMovement] No path found from {fromTile}. " +
"TowerPlacementManager should have prevented a full block.");
}
}
}