Unity 2D 按指定数量批量派遣部队至目标点的技术实现问询

Great question—you absolutely can reuse your existing float variable for this, with just a few small adjustments to handle integer troop counts and batch logic. Let’s break down how to implement both features, plus the best way to work with your current setup.

1. Dispatching Troops to a Target via Raycast #

First, we’ll handle input validation, raycast targeting, and deducting troops from your float count. Here’s a step-by-step implementation:

Core Logic #

• Convert your float count to an integer (using Mathf.FloorToInt) to get the number of fully ready troops.
• Validate that the requested dispatch amount doesn’t exceed available troops.
• Use Physics2D.Raycast to get a valid target point from the player’s input (e.g., mouse click).
• Calculate how many full batches fit into the requested amount, plus any leftover troops.
• Deduct the total dispatched troops from your float count.

Example Code Snippet #

// Your existing variables
public float troopCount = 0f;
public int batchSize = 5;
public GameObject troopPrefab;
public LayerMask groundTargetLayer;

public void DispatchRequestedTroops(int requestedAmount)
{
    // Get integer count of ready troops
    int availableTroops = Mathf.FloorToInt(troopCount);
    
    // Validate request
    if (requestedAmount <= 0 || requestedAmount > availableTroops)
    {
        Debug.Log("Invalid request—check troop count!");
        return;
    }
    
    // Get target via 2D raycast
    Vector2 mouseWorldPos = Camera.main.ScreenToWorldPoint(Input.mousePosition);
    RaycastHit2D hit = Physics2D.Raycast(mouseWorldPos, Vector2.zero, Mathf.Infinity, groundTargetLayer);
    
    if (!hit)
    {
        Debug.Log("No valid target selected!");
        return;
    }
    Vector2 targetPoint = hit.point;
    
    // Calculate batches and leftovers
    int fullBatches = requestedAmount / batchSize;
    int remainingTroops = requestedAmount % batchSize;
    
    // Dispatch batches
    for (int i = 0; i < fullBatches; i++)
    {
        SpawnAndMoveBatch(batchSize, targetPoint);
    }
    if (remainingTroops > 0)
    {
        SpawnAndMoveBatch(remainingTroops, targetPoint);
    }
    
    // Deduct from your float count
    troopCount -= requestedAmount;
}

2. Batch Movement (Instead of Single Troops) #

To keep troops moving as a group, you have two simple options:

Option 1: Parent Object Grouping #

Create an empty parent object for each batch, attach movement logic to the parent, and spawn troops as children. This ensures the entire batch moves together.

private void SpawnAndMoveBatch(int batchSize, Vector2 target)
{
    // Create a batch parent to handle group movement
    GameObject batchParent = new GameObject($"Troop Batch {Time.time}");
    Vector2 spawnPos = transform.position; // Your starting point
    
    // Spawn troops as children of the batch
    for (int i = 0; i < batchSize; i++)
    {
        GameObject troop = Instantiate(troopPrefab, spawnPos, Quaternion.identity);
        troop.transform.parent = batchParent.transform;
        // Add small offsets to avoid overlapping troops
        troop.transform.localPosition = new Vector3((i % 5) * 0.3f, (i / 5) * 0.3f, 0);
    }
    
    // Attach movement to the batch parent
    BatchMovement batchMovement = batchParent.AddComponent<BatchMovement>();
    batchMovement.SetTarget(target);
}

// BatchMovement.cs (separate script)
public class BatchMovement : MonoBehaviour
{
    public float moveSpeed = 2f;
    private Vector2 target;
    
    public void SetTarget(Vector2 newTarget)
    {
        target = newTarget;
    }
    
    void Update()
    {
        transform.position = Vector2.MoveTowards(transform.position, target, moveSpeed * Time.deltaTime);
        
        // Clean up batch once it reaches the target
        if (Vector2.Distance(transform.position, target) < 0.1f)
        {
            // Optional: Detach troops from parent before destroying
            foreach (Transform troop in transform)
            {
                troop.parent = null;
            }
            Destroy(gameObject);
        }
    }
}

Option 2: Formation Movement #

If you want troops to maintain a specific formation (e.g., a grid), have each troop track a relative position to a "leader" troop in the batch. This works well if you need more precise control over spacing.

Reusing Your Float Variable: Is It Feasible? #

Yes—this is actually the most efficient approach! Here’s why:

• Your float tracks partial troop progress (e.g., 3.7f means 3 ready troops, plus 0.7 seconds until the 4th). Using Mathf.FloorToInt(troopCount) gives you the exact number of dispatchable troops at any time.
• When you deduct troops, subtract the integer amount (e.g., troopCount -= 5 for a batch) to keep the float accurate for ongoing accumulation.
• You don’t need a separate integer variable unless you want to track ready troops explicitly—but reusing the float keeps your code simpler.

Alternative (If You Prefer Separate Tracking) #

If you find float-to-integer conversion tedious, you could add two variables:

• float troopAccumulator: Tracks the second-by-second increment.
• int readyTroops: When troopAccumulator >= 1f, add 1 to readyTroops and subtract 1 from troopAccumulator.

But this is optional—your existing float setup works perfectly with the conversion logic above.

内容的提问来源于stack exchange，提问作者Nils Leonhardt