Unity中C#程序化生成：如何固定数量并实现带权重3D平台机制？

Hey there! Let's tackle your Unity procedural generation questions step by step—sounds like you're building a fun platformer with weighted spawns, which is a great foundation for dynamic level design.

The core of generating a fixed number of elements is controlling the loop execution count. Here's how to combine that with your weighted platform system and spawn direction logic:

Step 1: Define Your Data Structures #

First, formalize your platform data (weight, allowed spawn directions) so it's easy to work with in code:

// Enum for spawn directions (matches your manual setup)
public enum SpawnDirection { Up, Down, Front, Back, Left, Right }

// Serializable class to store platform prefab, weight, and allowed directions
[System.Serializable]
public class PlatformData
{
    public GameObject platformPrefab;
    public int spawnWeight; // Higher values = more likely to be selected
    public List<SpawnDirection> allowedSpawnDirections;
}

Step 2: Fixed-Count Generation Logic #

Use a for loop to explicitly generate exactly the number of platforms you want. Pair this with a weighted random selection to pick which platform type to spawn, then calculate the spawn position based on the allowed directions:

public class PlatformGenerator : MonoBehaviour
{
    [Header("Generation Settings")]
    public List<PlatformData> platformLibrary;
    public int totalPlatformsToGenerate = 25; // Your fixed number here
    public Transform startingPlatform; // The first platform the player starts on

    private void Start()
    {
        GenerateFixedPlatformSet();
    }

    private void GenerateFixedPlatformSet()
    {
        Transform currentAnchor = startingPlatform;

        // Loop exactly 'totalPlatformsToGenerate' times to hit your fixed count
        for (int platformIndex = 0; platformIndex < totalPlatformsToGenerate; platformIndex++)
        {
            // 1. Pick a platform type using weighted random selection
            PlatformData selectedPlatform = GetWeightedRandomPlatform();
            if (selectedPlatform == null) break; // Fallback if weights are misconfigured

            // 2. Choose a valid spawn direction from the platform's allowed list
            SpawnDirection randomValidDirection = selectedPlatform.allowedSpawnDirections[
                Random.Range(0, selectedPlatform.allowedSpawnDirections.Count)
            ];

            // 3. Calculate the spawn position relative to the current platform
            Vector3 spawnPosition = CalculateSpawnPoint(currentAnchor, randomValidDirection);

            // 4. Spawn the platform and update the anchor for the next iteration
            GameObject newPlatform = Instantiate(
                selectedPlatform.platformPrefab,
                spawnPosition,
                currentAnchor.rotation // Match rotation for consistent orientation
            );
            currentAnchor = newPlatform.transform;
        }
    }

    // Helper: Weighted random selection for platforms
    private PlatformData GetWeightedRandomPlatform()
    {
        int totalWeight = platformLibrary.Sum(platform => platform.spawnWeight);
        if (totalWeight <= 0) return null; // Guard against invalid weights

        int randomRoll = Random.Range(0, totalWeight);
        int cumulativeWeight = 0;

        foreach (var platform in platformLibrary)
        {
            cumulativeWeight += platform.spawnWeight;
            if (randomRoll < cumulativeWeight)
            {
                return platform;
            }
        }

        return null; // Shouldn't reach here if weights are set correctly
    }

    // Helper: Calculate spawn position based on direction (adjust for your platform size!)
    private Vector3 CalculateSpawnPoint(Transform currentPlatform, SpawnDirection direction)
    {
        float platformOffset = 2f; // Adjust this to match your platform's scale/size
        Vector3 offset = Vector3.zero;

        switch (direction)
        {
            case SpawnDirection.Up:
                offset = Vector3.up * platformOffset;
                break;
            case SpawnDirection.Down:
                offset = Vector3.down * platformOffset;
                break;
            case SpawnDirection.Front:
                offset = currentPlatform.forward * platformOffset;
                break;
            case SpawnDirection.Back:
                offset = -currentPlatform.forward * platformOffset;
                break;
            case SpawnDirection.Left:
                offset = -currentPlatform.right * platformOffset;
                break;
            case SpawnDirection.Right:
                offset = currentPlatform.right * platformOffset;
                break;
        }

        return currentPlatform.position + offset;
    }
}

Key Notes for Fixed-Count Generation #

• Loop Control: The for loop runs exactly totalPlatformsToGenerate times, so you'll always get that number of platforms (assuming no null returns from the weighted selection).
• Weight Consistency: Make sure your platform weights are positive integers—if all weights are 0, the selection will fail (hence the guard clause).
• Spawn Position Safety: Adjust platformOffset to match your actual platform dimensions to avoid overlapping or gaps between platforms.

You mentioned something about platforms behaving a certain way before the player first steps on them—feel free to share the full details! Common implementations here include:

• Fading in the platform when the player approaches
• Disabling collision until the player steps on it
• Playing an animation (like popping into existence) when the player gets close
• Toggling physics (e.g., making the platform float until interacted with)

Let me know what you had in mind, and I can help you flesh out that logic!

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