455 lines
16 KiB
C#
455 lines
16 KiB
C#
using Unity.Netcode;
|
|
using UnityEngine;
|
|
using UnityEngine.InputSystem;
|
|
|
|
namespace Northbound
|
|
{
|
|
public class BuildingPlacement : NetworkBehaviour
|
|
{
|
|
[Header("Settings")]
|
|
public LayerMask groundLayer;
|
|
public float maxPlacementDistance = 100f;
|
|
|
|
[Header("Preview Materials")]
|
|
public Material validMaterial;
|
|
public Material invalidMaterial;
|
|
|
|
[Header("Current Selection")]
|
|
public int selectedBuildingIndex = 0;
|
|
|
|
[Header("Debug Visualization")]
|
|
public bool showGridBounds = true;
|
|
|
|
private bool isBuildModeActive = false;
|
|
private GameObject previewObject;
|
|
private int currentRotation = 0; // 0-3
|
|
private Material[] originalMaterials;
|
|
private Renderer[] previewRenderers;
|
|
private PlayerInputActions _inputActions;
|
|
|
|
public override void OnNetworkSpawn()
|
|
{
|
|
if (!IsOwner) return;
|
|
|
|
_inputActions = new PlayerInputActions();
|
|
_inputActions.Player.ToggleBuildMode.performed += OnToggleBuildMode;
|
|
_inputActions.Player.Rotate.performed += OnRotate;
|
|
_inputActions.Player.Build.performed += OnBuild;
|
|
_inputActions.Enable();
|
|
|
|
// Create default materials if not assigned
|
|
if (validMaterial == null)
|
|
{
|
|
validMaterial = CreateGhostMaterial(new Color(0, 1, 0, 0.5f));
|
|
}
|
|
|
|
if (invalidMaterial == null)
|
|
{
|
|
invalidMaterial = CreateGhostMaterial(new Color(1, 0, 0, 0.5f));
|
|
}
|
|
}
|
|
|
|
private Material CreateGhostMaterial(Color color)
|
|
{
|
|
// Try to find appropriate shader for current render pipeline
|
|
Shader shader = Shader.Find("Universal Render Pipeline/Lit");
|
|
if (shader == null)
|
|
shader = Shader.Find("Standard");
|
|
if (shader == null)
|
|
shader = Shader.Find("Diffuse");
|
|
|
|
Material mat = new Material(shader);
|
|
|
|
// Set base color
|
|
if (mat.HasProperty("_BaseColor"))
|
|
mat.SetColor("_BaseColor", color); // URP
|
|
else if (mat.HasProperty("_Color"))
|
|
mat.SetColor("_Color", color); // Standard
|
|
|
|
// Enable transparency
|
|
if (mat.HasProperty("_Surface"))
|
|
{
|
|
// URP Transparency
|
|
mat.SetFloat("_Surface", 1); // Transparent
|
|
mat.SetFloat("_Blend", 0); // Alpha
|
|
mat.SetFloat("_AlphaClip", 0);
|
|
mat.SetFloat("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
|
|
mat.SetFloat("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
|
|
mat.SetFloat("_ZWrite", 0);
|
|
mat.renderQueue = 3000;
|
|
mat.EnableKeyword("_SURFACE_TYPE_TRANSPARENT");
|
|
mat.EnableKeyword("_ALPHAPREMULTIPLY_ON");
|
|
}
|
|
else
|
|
{
|
|
// Standard RP Transparency
|
|
mat.SetFloat("_Mode", 3); // Transparent mode
|
|
mat.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.SrcAlpha);
|
|
mat.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.OneMinusSrcAlpha);
|
|
mat.SetInt("_ZWrite", 0);
|
|
mat.DisableKeyword("_ALPHATEST_ON");
|
|
mat.EnableKeyword("_ALPHABLEND_ON");
|
|
mat.DisableKeyword("_ALPHAPREMULTIPLY_ON");
|
|
mat.renderQueue = 3000;
|
|
}
|
|
|
|
return mat;
|
|
}
|
|
|
|
public override void OnNetworkDespawn()
|
|
{
|
|
if (IsOwner && _inputActions != null)
|
|
{
|
|
_inputActions.Player.ToggleBuildMode.performed -= OnToggleBuildMode;
|
|
_inputActions.Player.Rotate.performed -= OnRotate;
|
|
_inputActions.Player.Build.performed -= OnBuild;
|
|
_inputActions.Disable();
|
|
_inputActions.Dispose();
|
|
}
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
if (!IsOwner) return;
|
|
|
|
if (isBuildModeActive)
|
|
{
|
|
UpdatePreviewPosition();
|
|
}
|
|
}
|
|
|
|
private void OnDrawGizmos()
|
|
{
|
|
if (!IsOwner || !isBuildModeActive || !showGridBounds) return;
|
|
if (BuildingManager.Instance == null || previewObject == null || !previewObject.activeSelf) return;
|
|
|
|
BuildingData data = BuildingManager.Instance.availableBuildings[selectedBuildingIndex];
|
|
if (data == null) return;
|
|
|
|
// Draw grid bounds being used for collision detection
|
|
Bounds bounds = BuildingManager.Instance.GetPlacementBounds(data, previewObject.transform.position, currentRotation);
|
|
|
|
// Check if valid
|
|
bool isValid = BuildingManager.Instance.IsValidPlacement(data, previewObject.transform.position, currentRotation, out _);
|
|
|
|
Gizmos.color = isValid ? new Color(0, 1, 0, 0.5f) : new Color(1, 0, 0, 0.5f);
|
|
Gizmos.DrawWireCube(bounds.center, bounds.size);
|
|
|
|
// Draw grid cells
|
|
Gizmos.color = Color.yellow;
|
|
float gridSize = BuildingManager.Instance.gridSize;
|
|
Vector3 snappedPos = BuildingManager.Instance.SnapToGrid(previewObject.transform.position);
|
|
|
|
// Draw grid origin point
|
|
Gizmos.DrawSphere(snappedPos, 0.1f);
|
|
|
|
// Draw grid outline for each cell
|
|
int width = Mathf.RoundToInt(bounds.size.x / gridSize);
|
|
int length = Mathf.RoundToInt(bounds.size.z / gridSize);
|
|
|
|
for (int x = 0; x < width; x++)
|
|
{
|
|
for (int z = 0; z < length; z++)
|
|
{
|
|
Vector3 cellPos = snappedPos + new Vector3(
|
|
(x - width / 2f + 0.5f) * gridSize,
|
|
0.01f,
|
|
(z - length / 2f + 0.5f) * gridSize
|
|
);
|
|
Gizmos.DrawWireCube(cellPos, new Vector3(gridSize, 0.01f, gridSize));
|
|
}
|
|
}
|
|
}
|
|
|
|
private void OnToggleBuildMode(InputAction.CallbackContext context)
|
|
{
|
|
ToggleBuildMode();
|
|
}
|
|
|
|
private void OnRotate(InputAction.CallbackContext context)
|
|
{
|
|
if (!isBuildModeActive) return;
|
|
|
|
float rotateValue = context.ReadValue<float>();
|
|
if (rotateValue > 0)
|
|
{
|
|
currentRotation = (currentRotation + 1) % 4;
|
|
}
|
|
else if (rotateValue < 0)
|
|
{
|
|
currentRotation = (currentRotation - 1 + 4) % 4;
|
|
}
|
|
}
|
|
|
|
private void OnBuild(InputAction.CallbackContext context)
|
|
{
|
|
if (!isBuildModeActive) return;
|
|
TryPlaceBuilding();
|
|
}
|
|
|
|
private void ToggleBuildMode()
|
|
{
|
|
isBuildModeActive = !isBuildModeActive;
|
|
|
|
if (isBuildModeActive)
|
|
{
|
|
EnterBuildMode();
|
|
}
|
|
else
|
|
{
|
|
ExitBuildMode();
|
|
}
|
|
}
|
|
|
|
private void EnterBuildMode()
|
|
{
|
|
currentRotation = 0;
|
|
CreatePreview();
|
|
}
|
|
|
|
private void ExitBuildMode()
|
|
{
|
|
DestroyPreview();
|
|
}
|
|
|
|
private void CreatePreview()
|
|
{
|
|
if (BuildingManager.Instance == null)
|
|
return;
|
|
|
|
if (BuildingManager.Instance.availableBuildings.Count == 0)
|
|
return;
|
|
|
|
selectedBuildingIndex = Mathf.Clamp(selectedBuildingIndex, 0,
|
|
BuildingManager.Instance.availableBuildings.Count - 1);
|
|
|
|
BuildingData data = BuildingManager.Instance.availableBuildings[selectedBuildingIndex];
|
|
if (data == null || data.prefab == null)
|
|
return;
|
|
|
|
previewObject = Instantiate(data.prefab);
|
|
previewObject.name = "BuildingPreview";
|
|
|
|
// Disable colliders on preview
|
|
foreach (var collider in previewObject.GetComponentsInChildren<Collider>())
|
|
{
|
|
collider.enabled = false;
|
|
}
|
|
|
|
// Remove NetworkObject from preview if exists
|
|
NetworkObject netObj = previewObject.GetComponent<NetworkObject>();
|
|
if (netObj != null)
|
|
{
|
|
Destroy(netObj);
|
|
}
|
|
|
|
// Store original materials and setup preview renderers
|
|
previewRenderers = previewObject.GetComponentsInChildren<Renderer>();
|
|
|
|
if (previewRenderers.Length == 0)
|
|
{
|
|
// Add a debug cube so you can at least see something
|
|
GameObject debugCube = GameObject.CreatePrimitive(PrimitiveType.Cube);
|
|
debugCube.transform.SetParent(previewObject.transform);
|
|
debugCube.transform.localPosition = Vector3.zero;
|
|
Destroy(debugCube.GetComponent<Collider>());
|
|
previewRenderers = previewObject.GetComponentsInChildren<Renderer>();
|
|
}
|
|
|
|
originalMaterials = new Material[previewRenderers.Length];
|
|
|
|
for (int i = 0; i < previewRenderers.Length; i++)
|
|
{
|
|
originalMaterials[i] = previewRenderers[i].material;
|
|
// Replace all materials with ghost material
|
|
Material[] mats = new Material[previewRenderers[i].materials.Length];
|
|
for (int j = 0; j < mats.Length; j++)
|
|
{
|
|
mats[j] = validMaterial;
|
|
}
|
|
previewRenderers[i].materials = mats;
|
|
|
|
// Disable shadow casting
|
|
previewRenderers[i].shadowCastingMode = UnityEngine.Rendering.ShadowCastingMode.Off;
|
|
previewRenderers[i].receiveShadows = false;
|
|
}
|
|
}
|
|
|
|
private void DestroyPreview()
|
|
{
|
|
if (previewObject != null)
|
|
{
|
|
Destroy(previewObject);
|
|
previewObject = null;
|
|
}
|
|
}
|
|
|
|
private void UpdatePreviewPosition()
|
|
{
|
|
if (BuildingManager.Instance == null) return;
|
|
|
|
if (previewObject == null)
|
|
{
|
|
CreatePreview();
|
|
if (previewObject == null) return;
|
|
}
|
|
|
|
if (Mouse.current == null)
|
|
return;
|
|
|
|
Vector2 mousePos = Mouse.current.position.ReadValue();
|
|
Ray ray = Camera.main.ScreenPointToRay(mousePos);
|
|
|
|
Vector3 targetPosition = Vector3.zero;
|
|
bool foundPosition = false;
|
|
|
|
// Robust approach: Find where ray intersects ground plane, then raycast down from there
|
|
// This works even when pointing at empty space between buildings
|
|
|
|
// Step 1: Calculate where ray intersects a horizontal plane at Y=0
|
|
// Using plane intersection math
|
|
Plane groundPlane = new Plane(Vector3.up, Vector3.zero);
|
|
float enter;
|
|
|
|
if (groundPlane.Raycast(ray, out enter))
|
|
{
|
|
// Get the XZ position where ray hits the ground plane
|
|
Vector3 planeHitPoint = ray.GetPoint(enter);
|
|
|
|
// Step 2: Cast down from above this XZ position to find actual ground
|
|
Vector3 highPoint = new Vector3(planeHitPoint.x, 100f, planeHitPoint.z);
|
|
|
|
if (Physics.Raycast(highPoint, Vector3.down, out RaycastHit downHit, 200f, groundLayer))
|
|
{
|
|
// Always use the hit point
|
|
targetPosition = downHit.point;
|
|
foundPosition = true;
|
|
}
|
|
else
|
|
{
|
|
// No ground found via raycast, use the plane intersection point directly
|
|
targetPosition = planeHitPoint;
|
|
foundPosition = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Fallback: Try direct raycast to anything
|
|
if (Physics.Raycast(ray, out RaycastHit anyHit, maxPlacementDistance))
|
|
{
|
|
targetPosition = anyHit.point;
|
|
foundPosition = true;
|
|
}
|
|
}
|
|
|
|
if (foundPosition)
|
|
{
|
|
BuildingData data = BuildingManager.Instance.availableBuildings[selectedBuildingIndex];
|
|
|
|
// IsValidPlacement now returns the snapped position in groundPosition
|
|
bool isValid = BuildingManager.Instance.IsValidPlacement(data, targetPosition, currentRotation, out Vector3 snappedPosition);
|
|
|
|
previewObject.transform.position = snappedPosition + data.placementOffset;
|
|
previewObject.transform.rotation = Quaternion.Euler(0, currentRotation * 90f, 0);
|
|
|
|
if (!previewObject.activeSelf)
|
|
{
|
|
previewObject.SetActive(true);
|
|
}
|
|
|
|
// Update material
|
|
Material previewMat = isValid ? validMaterial : invalidMaterial;
|
|
foreach (var renderer in previewRenderers)
|
|
{
|
|
Material[] mats = new Material[renderer.materials.Length];
|
|
for (int i = 0; i < mats.Length; i++)
|
|
{
|
|
mats[i] = previewMat;
|
|
}
|
|
renderer.materials = mats;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (previewObject.activeSelf)
|
|
{
|
|
previewObject.SetActive(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void TryPlaceBuilding()
|
|
{
|
|
if (previewObject == null || !previewObject.activeSelf) return;
|
|
|
|
Vector2 mousePos = Mouse.current.position.ReadValue();
|
|
Ray ray = Camera.main.ScreenPointToRay(mousePos);
|
|
|
|
Vector3 targetPosition = Vector3.zero;
|
|
bool foundPosition = false;
|
|
|
|
// Use plane intersection to get XZ position, then raycast down to find ground
|
|
Plane groundPlane = new Plane(Vector3.up, Vector3.zero);
|
|
float enter;
|
|
|
|
if (groundPlane.Raycast(ray, out enter))
|
|
{
|
|
Vector3 planeHitPoint = ray.GetPoint(enter);
|
|
Vector3 highPoint = new Vector3(planeHitPoint.x, 100f, planeHitPoint.z);
|
|
|
|
if (Physics.Raycast(highPoint, Vector3.down, out RaycastHit downHit, 200f, groundLayer))
|
|
{
|
|
if (downHit.collider.GetComponentInParent<Building>() == null)
|
|
{
|
|
targetPosition = downHit.point;
|
|
foundPosition = true;
|
|
}
|
|
else
|
|
{
|
|
targetPosition = downHit.point;
|
|
foundPosition = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
targetPosition = planeHitPoint;
|
|
foundPosition = true;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Fallback: direct raycast
|
|
if (Physics.Raycast(ray, out RaycastHit anyHit, maxPlacementDistance))
|
|
{
|
|
targetPosition = anyHit.point;
|
|
foundPosition = true;
|
|
}
|
|
}
|
|
|
|
if (foundPosition)
|
|
{
|
|
BuildingData data = BuildingManager.Instance.availableBuildings[selectedBuildingIndex];
|
|
|
|
// IsValidPlacement now returns the snapped position
|
|
if (BuildingManager.Instance.IsValidPlacement(data, targetPosition, currentRotation, out Vector3 snappedPosition))
|
|
{
|
|
BuildingManager.Instance.PlaceBuildingServerRpc(selectedBuildingIndex, snappedPosition, currentRotation);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
override public void OnDestroy()
|
|
{
|
|
DestroyPreview();
|
|
|
|
if (_inputActions != null)
|
|
{
|
|
_inputActions.Dispose();
|
|
}
|
|
|
|
base.OnDestroy();
|
|
}
|
|
}
|
|
}
|