如何使用Unity写一个基地建造系统

在Unity中编写一个基地建造系统需要结合Unity的核心功能（如GameObject、Raycasting、UI和Prefab等）来实现。这是一个分步的教程，帮助你理解和实现一个基本的基地建造系统。

功能需求分解

一个简单的基地建造系统通常包括以下功能：

  1. 建筑选择：玩家可以选择要建造的建筑类型。
  2. 建筑放置：玩家可以将建筑放置在地形上。
  3. 放置验证：建筑物只能放置在合法的区域（如不重叠、不超出边界）。
  4. 建筑确认：确认放置后，建筑从“预览模式”变为“固定模式”。
  5. 资源消耗（可选）：建造需要消耗资源。
  6. 建筑交互（可选）：玩家可以与建造的建筑物进行交互。

实现步骤

1. 创建基础项目

  1. 设置场景：

    • 创建一个平坦的地形（例如，使用Plane作为地面）。
    • 准备一些建筑的Prefab（例如房子、工厂等）。

  2. 准备资源：

    • 创建一个UI面板，用于选择建筑类型。
    • 准备一个用于放置预览的透明建筑材质（例如半透明的绿色和红色材质，用于合法和非法放置的反馈）。
2. 编码实现
Step 1: 建立建筑管理器

创建一个脚本BuildingManager来管理建筑的创建和放置逻辑。

  1. using UnityEngine;
  2.  
  3. public class BuildingManager : MonoBehaviour
  4. {
  5.     public GameObject[] buildingPrefabs; // 可建造的建筑Prefab列表
  6.     public LayerMask groundLayer;        // 地形的Layer
  7.     public Material validPlacementMat;  // 合法放置的材质
  8.     public Material invalidPlacementMat;// 非法放置的材质
  9.  
  10.     private GameObject currentBuilding;  // 当前正在放置的建筑
  11.     private bool isPlacing = false;      // 是否处于放置模式
  12.     private Renderer currentRenderer;    // 当前建筑的Renderer
  13.  
  14.     void Update()
  15.     {
  16.         // 检查是否在放置模式
  17.         if (isPlacing)
  18.         {
  19.             HandlePlacement();
  20.         }
  21.     }
  22.  
  23.     public void StartPlacing(int buildingIndex)
  24.     {
  25.         if (buildingIndex < 0 || buildingIndex >= buildingPrefabs.Length) return;
  26.  
  27.         // 创建一个建筑的预览对象
  28.         currentBuilding = Instantiate(buildingPrefabs[buildingIndex]);
  29.         currentRenderer = currentBuilding.GetComponent<Renderer>();
  30.  
  31.         // 设置为放置模式
  32.         isPlacing = true;
  33.     }
  34.  
  35.     private void HandlePlacement()
  36.     {
  37.         // 使用Raycast检测鼠标位置
  38.         Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
  39.         if (Physics.Raycast(ray, out RaycastHit hit, Mathf.Infinity, groundLayer))
  40.         {
  41.             // 将建筑移动到鼠标位置
  42.             currentBuilding.transform.position = hit.point;
  43.  
  44.             // 检测是否可以放置
  45.             if (CanPlaceBuilding())
  46.             {
  47.                 ApplyMaterial(validPlacementMat); // 合法放置
  48.                 if (Input.GetMouseButtonDown(0)) // 左键点击确认建造
  49.                 {
  50.                     ConfirmPlacement();
  51.                 }
  52.             }
  53.             else
  54.             {
  55.                 ApplyMaterial(invalidPlacementMat); // 非法放置
  56.             }
  57.         }
  58.  
  59.         // 取消建造模式（右键取消）
  60.         if (Input.GetMouseButtonDown(1))
  61.         {
  62.             CancelPlacement();
  63.         }
  64.     }
  65.  
  66.     private bool CanPlaceBuilding()
  67.     {
  68.         // 检测建筑是否与其他物体重叠
  69.         Collider[] colliders = Physics.OverlapBox(currentBuilding.transform.position, currentRenderer.bounds.extents);
  70.         return colliders.Length == 0; // 没有碰撞则可以放置
  71.     }
  72.  
  73.     private void ApplyMaterial(Material material)
  74.     {
  75.         if (currentRenderer != null)
  76.         {
  77.             currentRenderer.material = material;
  78.         }
  79.     }
  80.  
  81.     private void ConfirmPlacement()
  82.     {
  83.         // 确认放置后，取消透明材质
  84.         ApplyMaterial(null);
  85.  
  86.         // 固定建筑状态
  87.         currentBuilding = null;
  88.         currentRenderer = null;
  89.         isPlacing = false;
  90.     }
  91.  
  92.     private void CancelPlacement()
  93.     {
  94.         // 销毁当前建筑预览
  95.         Destroy(currentBuilding);
  96.         currentBuilding = null;
  97.         isPlacing = false;
  98.     }
  99. }
Step 2: 创建建筑选择UI
  1. 创建一个UI面板，用于选择建筑类型。
  2. 为每个按钮绑定一个方法，调用BuildingManager的StartPlacing方法。
  1. using UnityEngine;
  2.  
  3. public class UIManager : MonoBehaviour
  4. {
  5.     public BuildingManager buildingManager;
  6.  
  7.     public void OnSelectBuilding(int buildingIndex)
  8.     {
  9.         buildingManager.StartPlacing(buildingIndex);
  10.     }
  11. }

在Unity Editor中：

  • 创建一个Canvas。
  • 添加建筑类型的按钮，为每个按钮绑定UIManager.OnSelectBuilding方法，并传入不同的建筑索引。
Step 3: 设置地形检测

为地形设置一个专属的Layer（例如Ground），并在BuildingManager中设置groundLayer。

Step 4: 添加合法放置检测

在CanPlaceBuilding()方法中，你可以扩展逻辑，例如：

  • 检测建筑是否超出地形边界。
  • 检测是否与其他建筑重叠。
Step 5: 添加资源系统（可选）

如果需要资源消耗，可以为玩家创建一个资源管理器：

  1. public class ResourceManager : MonoBehaviour
  2. {
  3.     public int wood;
  4.     public int stone;
  5.  
  6.     public bool SpendResources(int woodCost, int stoneCost)
  7.     {
  8.         if (wood >= woodCost && stone >= stoneCost)
  9.         {
  10.             wood -= woodCost;
  11.             stone -= stoneCost;
  12.             return true;
  13.         }
  14.         return false;
  15.     }
  16. }

然后在ConfirmPlacement中检查是否有足够的资源：

  1. if (resourceManager.SpendResources(woodCost, stoneCost))
  2. {
  3.     ConfirmPlacement();
  4. }
  5. else
  6. {
  7.     Debug.Log("Not enough resources!");
  8. }
Step 6: 添加交互功能（可选）

在Unity中，为建筑物添加交互功能（如点击建筑后显示选项菜单或执行其他行为）需要结合鼠标点击检测和UI交互。以下是详细的实现步骤和代码：

功能需求

  1. 鼠标点击检测：玩家点击建筑时，能够检测到点击的建筑。
  2. 显示选项菜单：点击建筑后，弹出一个交互菜单（例如升级、拆除等选项）。
  3. 执行建筑功能：通过菜单按钮触发建筑操作（如升级或拆除）。

实现步骤

1. 为建筑添加交互组件

创建一个Building脚本，用于定义每个建筑的基本行为。

  1. using UnityEngine;
  2.  
  3. public class Building : MonoBehaviour
  4. {
  5.     public string buildingName = "Default Building"; // 建筑名称
  6.     public int level = 1; // 当前建筑等级
  7.     public int maxLevel = 3; // 最大等级
  8.  
  9.     // 升级建筑
  10.     public void Upgrade()
  11.     {
  12.         if (level < maxLevel)
  13.         {
  14.             level++;
  15.             Debug.Log($"{buildingName} 升级到等级 {level}！");
  16.             // 在这里添加具体的升级逻辑，例如改变外观或增加属性
  17.         }
  18.         else
  19.         {
  20.             Debug.Log($"{buildingName} 已达到最高等级！");
  21.         }
  22.     }
  23.  
  24.     // 拆除建筑
  25.     public void DestroyBuilding()
  26.     {
  27.         Debug.Log($"{buildingName} 被拆除！");
  28.         Destroy(gameObject);
  29.     }
  30. }
2. 创建交互菜单（UI部分）

  1. 创建Canvas：

    • 在Hierarchy中创建一个Canvas，将其渲染模式设置为Screen Space - Overlay。
    • 添加一个Panel作为菜单背景。
    • 在Panel中添加几个按钮，例如“升级”和“拆除”。

  2. 设置按钮行为：

    • 将每个按钮的OnClick事件绑定到交互脚本中。
3. 创建交互管理器

交互管理器负责处理玩家的鼠标点击事件以及显示/隐藏交互菜单。

交互管理器代码
  1. using UnityEngine;
  2. using UnityEngine.UI;
  3.  
  4. public class BuildingInteractionManager : MonoBehaviour
  5. {
  6.     public LayerMask buildingLayer;           // 建筑物的Layer，用于点击检测
  7.     public GameObject interactionMenu;       // 交互菜单的UI
  8.     public Text buildingNameText;            // 用于显示建筑名称
  9.     public Button upgradeButton;             // 升级按钮
  10.     public Button destroyButton;             // 拆除按钮
  11.  
  12.     private Building selectedBuilding;       // 当前选中的建筑
  13.  
  14.     void Update()
  15.     {
  16.         // 检测鼠标左键点击事件
  17.         if (Input.GetMouseButtonDown(0))
  18.         {
  19.             DetectBuilding();
  20.         }
  21.  
  22.         // 隐藏菜单（右键关闭）
  23.         if (Input.GetMouseButtonDown(1) && interactionMenu.activeSelf)
  24.         {
  25.             CloseInteractionMenu();
  26.         }
  27.     }
  28.  
  29.     private void DetectBuilding()
  30.     {
  31.         // 使用Raycast检测鼠标点击的建筑物
  32.         Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
  33.         if (Physics.Raycast(ray, out RaycastHit hit, Mathf.Infinity, buildingLayer))
  34.         {
  35.             Building building = hit.collider.GetComponent<Building>();
  36.             if (building != null)
  37.             {
  38.                 // 选中了建筑，打开交互菜单
  39.                 OpenInteractionMenu(building);
  40.             }
  41.         }
  42.     }
  43.  
  44.     private void OpenInteractionMenu(Building building)
  45.     {
  46.         selectedBuilding = building;
  47.  
  48.         // 设置菜单UI的位置（在建筑上方）
  49.         Vector3 menuPosition = Camera.main.WorldToScreenPoint(building.transform.position);
  50.         interactionMenu.transform.position = menuPosition;
  51.  
  52.         // 显示建筑名称
  53.         buildingNameText.text = building.buildingName;
  54.  
  55.         // 显示交互菜单
  56.         interactionMenu.SetActive(true);
  57.  
  58.         // 设置按钮事件
  59.         upgradeButton.onClick.RemoveAllListeners();
  60.         upgradeButton.onClick.AddListener(() => OnUpgradeBuilding());
  61.  
  62.         destroyButton.onClick.RemoveAllListeners();
  63.         destroyButton.onClick.AddListener(() => OnDestroyBuilding());
  64.     }
  65.  
  66.     private void CloseInteractionMenu()
  67.     {
  68.         interactionMenu.SetActive(false);
  69.         selectedBuilding = null;
  70.     }
  71.  
  72.     private void OnUpgradeBuilding()
  73.     {
  74.         if (selectedBuilding != null)
  75.         {
  76.             selectedBuilding.Upgrade();
  77.         }
  78.  
  79.         CloseInteractionMenu();
  80.     }
  81.  
  82.     private void OnDestroyBuilding()
  83.     {
  84.         if (selectedBuilding != null)
  85.         {
  86.             selectedBuilding.DestroyBuilding();
  87.         }
  88.  
  89.         CloseInteractionMenu();
  90.     }
  91. }
4. 配置交互系统

  1. 为建筑设置Layer：

    • 为所有可交互的建筑物设置一个专属的Layer（例如Building）。
    • 在BuildingInteractionManager中将buildingLayer设置为该Layer。

  2. 绑定交互菜单UI：

    • 将交互菜单的GameObject、Text组件和按钮组件拖拽到BuildingInteractionManager的对应字段。

  3. 为建筑物添加交互组件：

    • 将Building脚本附加到所有可交互的建筑物上。
5. 测试和优化
  • 点击建筑后，交互菜单应该显示在建筑上方，并显示建筑的名称。
  • 点击“升级”按钮，建筑的等级应该提升。
  • 点击“拆除”按钮，建筑应该被销毁。
  • 右键点击或点击其他地方时，交互菜单应该关闭。

完整交互菜单UI结构

以下是交互菜单的层级结构示例：

  1. Canvas
  2. └── InteractionMenu (Panel)
  3.     ├── BuildingName (Text)
  4.     ├── UpgradeButton (Button)
  5.     └── DestroyButton (Button)

扩展功能

  1. 动态检测建筑是否可升级或拆除：

    • 在OpenInteractionMenu中，根据建筑状态禁用或启用按钮： 
      upgradeButton.interactable = selectedBuilding.level < selectedBuilding.maxLevel;

  2. 支持多种建筑功能：

    • 添加更多按钮，触发如“生产资源”、“开启操作”等功能。

  3. 动画和特效：

    • 为菜单的打开和关闭添加动画效果。
    • 点击建筑后，让建筑高亮显示或播放特殊效果。

  4. 多建筑选择：

    • 支持框选多个建筑，批量执行操作。

完整交互效果

通过上述实现，玩家可以点击建筑打开交互菜单，菜单显示建筑的名称，并提供操作选项（如升级或拆除）。这种交互方式非常灵活，可以扩展为复杂的基地管理系统。

如果需要更复杂的功能（如多人游戏同步、不同建筑类型的专属操作），可以进一步封装每个建筑的行为逻辑，使用继承或接口来实现多态操作。

7. 添加建筑旋转功能

在大多数建造游戏中，玩家可以通过按键来旋转建筑。我们可以在放置模式中添加此功能。

实现建筑旋转

在BuildingManager中修改HandlePlacement方法，监听键盘按键（例如R键）来旋转当前建筑。

  1. private void HandlePlacement()
  2. {
  3.     // 使用Raycast检测鼠标位置
  4.     Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
  5.     if (Physics.Raycast(ray, out RaycastHit hit, Mathf.Infinity, groundLayer))
  6.     {
  7.         // 将建筑移动到鼠标位置
  8.         currentBuilding.transform.position = hit.point;
  9.  
  10.         // 检测是否可以放置
  11.         if (CanPlaceBuilding())
  12.         {
  13.             ApplyMaterial(validPlacementMat); // 合法放置
  14.             if (Input.GetMouseButtonDown(0)) // 左键点击确认建造
  15.             {
  16.                 ConfirmPlacement();
  17.             }
  18.         }
  19.         else
  20.         {
  21.             ApplyMaterial(invalidPlacementMat); // 非法放置
  22.         }
  23.     }
  24.  
  25.     // 添加旋转功能：按下R键旋转建筑
  26.     if (Input.GetKeyDown(KeyCode.R))
  27.     {
  28.         RotateBuilding();
  29.     }
  30.  
  31.     // 取消建造模式（右键取消）
  32.     if (Input.GetMouseButtonDown(1))
  33.     {
  34.         CancelPlacement();
  35.     }
  36. }
  37.  
  38. private void RotateBuilding()
  39. {
  40.     if (currentBuilding != null)
  41.     {
  42.         // 每次按键旋转90度
  43.         currentBuilding.transform.Rotate(0, 90, 0);
  44.     }
  45. }

8. 网格对齐功能

为了让建筑物对齐到网格（类似许多RTS游戏的网格建造系统），可以将建筑物的位置“吸附”到一个指定的网格。

实现网格对齐

网格对齐可以通过将建筑物的位置取整到网格大小的倍数来实现。

  1. private void HandlePlacement()
  2. {
  3.     Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
  4.     if (Physics.Raycast(ray, out RaycastHit hit, Mathf.Infinity, groundLayer))
  5.     {
  6.         // 将建筑移动到鼠标位置，并对齐到网格
  7.         Vector3 alignedPosition = AlignToGrid(hit.point);
  8.         currentBuilding.transform.position = alignedPosition;
  9.  
  10.         // 检测是否可以放置
  11.         if (CanPlaceBuilding())
  12.         {
  13.             ApplyMaterial(validPlacementMat);
  14.             if (Input.GetMouseButtonDown(0)) // 左键点击确认建造
  15.             {
  16.                 ConfirmPlacement();
  17.             }
  18.         }
  19.         else
  20.         {
  21.             ApplyMaterial(invalidPlacementMat);
  22.         }
  23.     }
  24.  
  25.     if (Input.GetMouseButtonDown(1))
  26.     {
  27.         CancelPlacement();
  28.     }
  29. }
  30.  
  31. private Vector3 AlignToGrid(Vector3 position)
  32. {
  33.     float gridSize = 1.0f; // 设置网格大小
  34.     float x = Mathf.Round(position.x / gridSize) * gridSize;
  35.     float z = Mathf.Round(position.z / gridSize) * gridSize;
  36.  
  37.     return new Vector3(x, position.y, z);
  38. }

9. 添加建筑升级和拆除功能

玩家可能需要对建筑进行升级、移动或拆除。我们可以通过点击建筑触发交互菜单来实现这些功能。

为建筑添加交互脚本

创建一个Building脚本，作为所有建筑的通用逻辑。

  1. using UnityEngine;
  2.  
  3. public class Building : MonoBehaviour
  4. {
  5.     public int level = 1; // 当前建筑等级
  6.     public int maxLevel = 3; // 最大等级
  7.  
  8.     // 升级建筑
  9.     public void Upgrade()
  10.     {
  11.         if (level < maxLevel)
  12.         {
  13.             level++;
  14.             Debug.Log($"建筑升级到等级 {level}");
  15.  
  16.             // 在这里可以添加升级逻辑，例如改变外观或属性
  17.         }
  18.         else
  19.         {
  20.             Debug.Log("建筑已达到最高等级！");
  21.         }
  22.     }
  23.  
  24.     // 拆除建筑
  25.     public void DestroyBuilding()
  26.     {
  27.         Debug.Log("建筑被拆除！");
  28.         Destroy(gameObject);
  29.     }
  30. }
点击建筑触发交互

通过使用Physics.Raycast检测玩家点击的建筑，我们可以打开交互菜单。

  1. using UnityEngine;
  2.  
  3. public class BuildingInteraction : MonoBehaviour
  4. {
  5.     public LayerMask buildingLayer; // 用于检测建筑物的Layer
  6.     public GameObject interactionMenu; // 交互菜单的UI
  7.  
  8.     private Building selectedBuilding;
  9.  
  10.     void Update()
  11.     {
  12.         if (Input.GetMouseButtonDown(0)) // 鼠标左键点击
  13.         {
  14.             Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
  15.             if (Physics.Raycast(ray, out RaycastHit hit, Mathf.Infinity, buildingLayer))
  16.             {
  17.                 Building building = hit.collider.GetComponent();
  18.                 if (building != null)
  19.                 {
  20.                     selectedBuilding = building;
  21.                     OpenInteractionMenu();
  22.                 }
  23.             }
  24.         }
  25.     }
  26.  
  27.     private void OpenInteractionMenu()
  28.     {
  29.         // 显示交互菜单
  30.         interactionMenu.SetActive(true);
  31.  
  32.         // 将菜单定位到建筑位置
  33.         interactionMenu.transform.position = Camera.main.WorldToScreenPoint(selectedBuilding.transform.position);
  34.     }
  35.  
  36.     public void OnUpgradeButton()
  37.     {
  38.         if (selectedBuilding != null)
  39.         {
  40.             selectedBuilding.Upgrade();
  41.         }
  42.     }
  43.  
  44.     public void OnDestroyButton()
  45.     {
  46.         if (selectedBuilding != null)
  47.         {
  48.             selectedBuilding.DestroyBuilding();
  49.             interactionMenu.SetActive(false);
  50.         }
  51.     }
  52. }

10. 动态网格检测（避免重叠）

为了确保建筑物不会重叠，可以使用一个二维数组或HashSet来跟踪每个网格是否已被占用。

实现动态网格检测

创建一个简单的网格管理器：

  1. using System.Collections.Generic;
  2. using UnityEngine;
  3.  
  4. public class GridManager : MonoBehaviour
  5. {
  6.     private HashSet<Vector2Int> occupiedCells = new HashSet<Vector2Int>();
  7.  
  8.     public bool IsCellOccupied(Vector3 position, float gridSize)
  9.     {
  10.         Vector2Int cell = GetCell(position, gridSize);
  11.         return occupiedCells.Contains(cell);
  12.     }
  13.  
  14.     public void MarkCell(Vector3 position, float gridSize)
  15.     {
  16.         Vector2Int cell = GetCell(position, gridSize);
  17.         occupiedCells.Add(cell);
  18.     }
  19.  
  20.     private Vector2Int GetCell(Vector3 position, float gridSize)
  21.     {
  22.         int x = Mathf.RoundToInt(position.x / gridSize);
  23.         int z = Mathf.RoundToInt(position.z / gridSize);
  24.         return new Vector2Int(x, z);
  25.     }
  26. }

在BuildingManager中，集成网格检测逻辑：

  1. private bool CanPlaceBuilding()
  2. {
  3.     float gridSize = 1.0f; // 网格大小
  4.     if (gridManager.IsCellOccupied(currentBuilding.transform.position, gridSize))
  5.     {
  6.         return false; // 位置已被占用
  7.     }
  8.  
  9.     Collider[] colliders = Physics.OverlapBox(currentBuilding.transform.position, currentRenderer.bounds.extents);
  10.     return colliders.Length == 0;
  11. }
  12.  
  13. private void ConfirmPlacement()
  14. {
  15.     float gridSize = 1.0f;
  16.     gridManager.MarkCell(currentBuilding.transform.position, gridSize);
  17.  
  18.     ApplyMaterial(null);
  19.     currentBuilding = null;
  20.     currentRenderer = null;
  21.     isPlacing = false;
  22. }

11. 动态地形支持

如果你的游戏有动态地形（例如高低起伏的地形），需要让建筑物自动适应地形的高度。

实现动态地形检测

在HandlePlacement中，通过Raycast检测地形高度，并调整建筑位置。

  1. private void HandlePlacement()
  2. {
  3.     Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
  4.     if (Physics.Raycast(ray, out RaycastHit hit, Mathf.Infinity, groundLayer))
  5.     {
  6.         Vector3 alignedPosition = AlignToGrid(hit.point);
  7.         alignedPosition.y = hit.point.y; // 设置为地形的高度
  8.         currentBuilding.transform.position = alignedPosition;
  9.  
  10.         if (CanPlaceBuilding())
  11.         {
  12.             ApplyMaterial(validPlacementMat);
  13.             if (Input.GetMouseButtonDown(0))
  14.             {
  15.                 ConfirmPlacement();
  16.             }
  17.         }
  18.         else
  19.         {
  20.             ApplyMaterial(invalidPlacementMat);
  21.         }
  22.     }
  23. }

结语

通过上述功能的实现，你可以打造一个功能丰富的基地建造系统。以下是一些可以继续改进的方向：

  1. AI路径规划：结合NavMesh，让单位能够避开建筑。
  2. 动态建筑属性：为建筑添加自定义属性，如产出资源、攻击能力等。
  3. 存档系统：保存和加载玩家的基地布局。
  4. 多人同步：在多人游戏中同步基地建造状态。

希望这些内容对你有所帮助，祝你开发顺利！

注：本文转载自blog.csdn.net的小宝哥Code的文章"https://blog.csdn.net/chenby186119/article/details/144210608"。版权归原作者所有，此博客不拥有其著作权，亦不承担相应法律责任。如有侵权，请联系我们删除。
复制链接
相关推荐
发表评论

评论记录：

未查询到任何数据！