387 lines
13 KiB
C#
387 lines
13 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using AceFieldNewHorizon.Scripts.Tiles;
|
|
using Godot;
|
|
using System.Linq;
|
|
|
|
namespace AceFieldNewHorizon.Scripts.System;
|
|
|
|
public partial class PlacementManager : Node2D
|
|
{
|
|
[Export] public GridManager Grid { get; set; }
|
|
[Export] public ResourceManager Inventory { get; set; }
|
|
[Export] public BuildingRegistry Registry { get; set; }
|
|
[Export] public int MaxConcurrentBuilds { get; set; } = 6; // Make it adjustable in editor
|
|
|
|
private static readonly List<string> BuildableTiles = ["wall", "miner"];
|
|
private readonly Dictionary<Node2D, BuildTask> _buildTasks = new();
|
|
private AudioStreamPlayer _completionSound;
|
|
|
|
public override void _Ready()
|
|
{
|
|
base._Ready();
|
|
|
|
// Setup completion sound
|
|
_completionSound = new AudioStreamPlayer();
|
|
AddChild(_completionSound);
|
|
var sound = GD.Load<AudioStream>("res://Sounds/Events/ConstructionComplete.wav");
|
|
if (sound != null)
|
|
{
|
|
_completionSound.Stream = sound;
|
|
}
|
|
}
|
|
|
|
private void OnBuildCompleted()
|
|
{
|
|
// Remove all completed builds
|
|
var completed = _buildTasks.Where(kvp => kvp.Value.IsCompleted)
|
|
.Select(kvp => kvp.Key)
|
|
.ToList();
|
|
foreach (var key in completed)
|
|
{
|
|
_buildTasks.Remove(key);
|
|
}
|
|
|
|
// If no builds left, play the completion sound
|
|
if (_buildTasks.Count == 0)
|
|
{
|
|
_completionSound.Play();
|
|
}
|
|
}
|
|
|
|
// Call this when starting a new build
|
|
private bool CanStartNewBuild()
|
|
{
|
|
// Remove completed builds
|
|
var completed = _buildTasks.Where(kvp => kvp.Value.IsCompleted)
|
|
.Select(kvp => kvp.Key)
|
|
.ToList();
|
|
foreach (var key in completed)
|
|
{
|
|
_buildTasks.Remove(key);
|
|
}
|
|
|
|
return _buildTasks.Count < MaxConcurrentBuilds;
|
|
}
|
|
|
|
private class BuildTask(Action onCompleted) : IDisposable
|
|
{
|
|
public bool IsCompleted { get; private set; }
|
|
public bool WasCancelled { get; private set; }
|
|
|
|
public void Complete(bool wasCancelled = false)
|
|
{
|
|
if (IsCompleted) return;
|
|
|
|
IsCompleted = true;
|
|
WasCancelled = wasCancelled;
|
|
onCompleted?.Invoke();
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
Complete(true); // Mark as cancelled if disposed before completion
|
|
}
|
|
}
|
|
|
|
private string _currentBuildingId = "wall";
|
|
private Vector2I _hoveredCell;
|
|
private BaseTile _ghostBuilding;
|
|
private float _currentRotation;
|
|
private Vector2I _currentBuildingSize = Vector2I.One;
|
|
|
|
public void SetCurrentBuilding(string buildingId)
|
|
{
|
|
_currentBuildingId = buildingId;
|
|
var buildingData = Registry.GetBuilding(buildingId);
|
|
if (buildingData != null)
|
|
{
|
|
_currentBuildingSize = buildingData.Size;
|
|
// Reset rotation to nearest allowed rotation
|
|
if (!buildingData.IsRotationAllowed(_currentRotation))
|
|
{
|
|
_currentRotation = (int)buildingData.AllowedRotations[0] * 90f;
|
|
}
|
|
}
|
|
|
|
// Replace ghost immediately
|
|
if (_ghostBuilding != null)
|
|
{
|
|
_ghostBuilding.QueueFree();
|
|
_ghostBuilding = null;
|
|
}
|
|
}
|
|
|
|
private void RotateGhost(bool reverse = false)
|
|
{
|
|
if (_ghostBuilding == null) return;
|
|
|
|
var buildingData = Registry.GetBuilding(_currentBuildingId);
|
|
if (buildingData == null) return;
|
|
|
|
// Calculate next rotation
|
|
var currentDirection = (RotationDirection)((Mathf.RoundToInt(_currentRotation / 90f) % 4 + 4) % 4);
|
|
var currentIndex = Array.IndexOf(buildingData.AllowedRotations.ToArray(), currentDirection);
|
|
|
|
if (reverse)
|
|
currentIndex = (currentIndex - 1 + buildingData.AllowedRotations.Length) %
|
|
buildingData.AllowedRotations.Length;
|
|
else
|
|
currentIndex = (currentIndex + 1) % buildingData.AllowedRotations.Length;
|
|
|
|
_currentRotation = (int)buildingData.AllowedRotations[currentIndex] * 90f;
|
|
_ghostBuilding.RotationDegrees = _currentRotation;
|
|
|
|
// Update ghost position to keep the same cell under cursor
|
|
UpdateGhostPosition();
|
|
}
|
|
|
|
private void UpdateGhostPosition()
|
|
{
|
|
if (_ghostBuilding == null) return;
|
|
|
|
var buildingData = Registry.GetBuilding(_currentBuildingId);
|
|
if (buildingData == null) return;
|
|
|
|
var rotatedSize = buildingData.GetRotatedSize(_currentRotation);
|
|
var offset = GridUtils.GetCenterOffset(rotatedSize, _currentRotation);
|
|
_ghostBuilding.Position = GridUtils.GridToWorld(_hoveredCell) + offset;
|
|
|
|
// Update occupied cells
|
|
GridUtils.GetOccupiedCells(_hoveredCell, rotatedSize, _currentRotation);
|
|
}
|
|
|
|
public override void _Process(double delta)
|
|
{
|
|
// Snap mouse to grid
|
|
var mousePos = GetGlobalMousePosition();
|
|
var newHoveredCell = GridUtils.WorldToGrid(mousePos);
|
|
|
|
// Only update if cell changed
|
|
if (newHoveredCell != _hoveredCell)
|
|
{
|
|
_hoveredCell = newHoveredCell;
|
|
UpdateGhostPosition();
|
|
}
|
|
|
|
if (Input.IsActionJustPressed("rotate_tile_reverse"))
|
|
RotateGhost(reverse: true);
|
|
else if (Input.IsActionJustPressed("rotate_tile"))
|
|
RotateGhost();
|
|
|
|
if (_ghostBuilding == null)
|
|
{
|
|
var building = Registry.GetBuilding(_currentBuildingId);
|
|
if (building == null) return;
|
|
var scene = building.Scene;
|
|
|
|
_ghostBuilding = (BaseTile)scene.Instantiate();
|
|
_ghostBuilding.SetGhostMode(true);
|
|
_ghostBuilding.RotationDegrees = _currentRotation;
|
|
_ghostBuilding.ZAsRelative = false;
|
|
_ghostBuilding.ZIndex = (int)building.Layer;
|
|
UpdateGhostPosition();
|
|
AddChild(_ghostBuilding);
|
|
}
|
|
|
|
var canPlace = CanPlaceBuilding();
|
|
_ghostBuilding.SetGhostMode(canPlace);
|
|
|
|
// Left click to place
|
|
if (Input.IsActionPressed("build_tile") && canPlace)
|
|
{
|
|
var building = Registry.GetBuilding(_currentBuildingId);
|
|
if (building == null) return;
|
|
|
|
if (!CanStartNewBuild())
|
|
{
|
|
// Optionally show feedback to player that build queue is full
|
|
return;
|
|
}
|
|
|
|
// Consume resources first
|
|
if (!ConsumeBuildingResources(_currentBuildingId))
|
|
{
|
|
// Optionally show feedback to player that they can't afford this building
|
|
return;
|
|
}
|
|
|
|
var scene = building.Scene;
|
|
var buildingInstance = (BaseTile)scene.Instantiate();
|
|
buildingInstance.RotationDegrees = _currentRotation;
|
|
buildingInstance.ZIndex = (int)building.Layer;
|
|
buildingInstance.Position = _ghostBuilding.Position;
|
|
AddChild(buildingInstance);
|
|
|
|
// Check if area is free before placing
|
|
if (!IsAreaFree(_hoveredCell, building.Size, _currentRotation, building.Layer))
|
|
{
|
|
RefundBuildingResources(_currentBuildingId);
|
|
buildingInstance.QueueFree();
|
|
return;
|
|
}
|
|
|
|
// Occupy the area
|
|
Grid.OccupyArea(_hoveredCell, buildingInstance, building.Size, _currentRotation, building.Layer);
|
|
|
|
if (building.BuildTime > 0f)
|
|
{
|
|
var buildTask = new BuildTask(OnBuildCompleted);
|
|
_buildTasks[buildingInstance] = buildTask;
|
|
|
|
buildingInstance.StartConstruction(building.BuildTime, () => {
|
|
// On construction complete
|
|
if (_buildTasks.TryGetValue(buildingInstance, out var task))
|
|
{
|
|
if (task.WasCancelled)
|
|
{
|
|
RefundBuildingResources(_currentBuildingId);
|
|
Grid.FreeArea(_hoveredCell, building.Size, _currentRotation, building.Layer);
|
|
buildingInstance.QueueFree();
|
|
}
|
|
task.Complete();
|
|
_buildTasks.Remove(buildingInstance);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
if (Input.IsActionPressed("destroy_tile") &&
|
|
!Grid.IsAreaFree(_hoveredCell, Vector2I.One, 0f))
|
|
{
|
|
// Right click to destroy from current layer
|
|
var building = Grid.GetBuildingAtCell(_hoveredCell);
|
|
if (building == null) return;
|
|
// Find all cells occupied by this building
|
|
var buildingInfo = Grid.GetBuildingInfoAtCell(_hoveredCell, GridLayer.Building);
|
|
if (buildingInfo == null) return;
|
|
building.QueueFree();
|
|
Grid.FreeArea(buildingInfo.Value.Position, buildingInfo.Value.Size, buildingInfo.Value.Rotation);
|
|
}
|
|
|
|
if (Input.IsActionJustPressed("switch_tile"))
|
|
{
|
|
var currentIdx = BuildableTiles.IndexOf(_currentBuildingId);
|
|
var nextIdx = (currentIdx + 1) % BuildableTiles.Count;
|
|
SetCurrentBuilding(BuildableTiles[nextIdx]);
|
|
}
|
|
}
|
|
|
|
public override void _ExitTree()
|
|
{
|
|
base._ExitTree();
|
|
_buildTasks.Clear();
|
|
}
|
|
|
|
private bool CanAffordBuilding(string buildingId)
|
|
{
|
|
if (Inventory == null) return false;
|
|
|
|
var buildingData = Registry.GetBuilding(buildingId);
|
|
if (buildingData == null) return false;
|
|
|
|
// Check if we have enough of each required resource
|
|
foreach (var (resourceId, amount) in buildingData.Cost)
|
|
if (!Inventory.HasResource(resourceId, amount))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
private bool ConsumeBuildingResources(string buildingId)
|
|
{
|
|
if (Inventory == null) return false;
|
|
|
|
var buildingData = Registry.GetBuilding(buildingId);
|
|
if (buildingData == null) return false;
|
|
|
|
// First verify we can afford it
|
|
if (!CanAffordBuilding(buildingId)) return false;
|
|
|
|
// Then consume each resource
|
|
foreach (var (resourceId, amount) in buildingData.Cost)
|
|
Inventory.RemoveResource(resourceId, amount);
|
|
|
|
return true;
|
|
}
|
|
|
|
private void RefundBuildingResources(string buildingId)
|
|
{
|
|
if (Inventory == null) return;
|
|
|
|
var buildingData = Registry.GetBuilding(buildingId);
|
|
if (buildingData == null) return;
|
|
|
|
// Refund each resource
|
|
foreach (var (resourceId, amount) in buildingData.Cost)
|
|
{
|
|
Inventory.AddResource(resourceId, amount);
|
|
}
|
|
}
|
|
|
|
private bool CanPlaceBuilding()
|
|
{
|
|
var buildingData = Registry.GetBuilding(_currentBuildingId);
|
|
if (buildingData == null) return false;
|
|
|
|
// Check if we can afford the building
|
|
if (!CanAffordBuilding(_currentBuildingId)) return false;
|
|
|
|
// Check if area is free
|
|
var rotatedSize = buildingData.GetRotatedSize(_currentRotation);
|
|
return !Grid.IsAreaOccupied(_hoveredCell, rotatedSize, _currentRotation, GetBlockingLayers(buildingData.Layer));
|
|
}
|
|
|
|
private GridLayer[] GetBlockingLayers(GridLayer layer)
|
|
{
|
|
return layer switch
|
|
{
|
|
GridLayer.Ground => [GridLayer.Ground],
|
|
GridLayer.Building => [GridLayer.Building],
|
|
GridLayer.Decoration => [GridLayer.Decoration],
|
|
_ => []
|
|
};
|
|
}
|
|
|
|
private bool IsAreaFree(Vector2I topLeft, Vector2I size, float rotation, GridLayer layer)
|
|
{
|
|
return !Grid.IsAreaOccupied(topLeft, size, rotation, GetBlockingLayers(layer));
|
|
}
|
|
}
|
|
|
|
public static class GridManagerExtensions
|
|
{
|
|
public static (Vector2I Position, Vector2I Size, float Rotation)? GetBuildingInfoAtCell(this GridManager grid,
|
|
Vector2I cell, GridLayer layer)
|
|
{
|
|
if (grid.GetBuildingAtCell(cell, layer) is { } building)
|
|
{
|
|
// Find the top-left position of the building
|
|
for (int x = 0; x < 100; x++) // Arbitrary max size
|
|
{
|
|
for (int y = 0; y < 100; y++)
|
|
{
|
|
var checkCell = new Vector2I(cell.X - x, cell.Y - y);
|
|
if (grid.GetBuildingAtCell(checkCell, layer) == building)
|
|
{
|
|
// Found the top-left corner, now find the size
|
|
var size = Vector2I.One;
|
|
// Search right
|
|
while (grid.GetBuildingAtCell(new Vector2I(checkCell.X + size.X, checkCell.Y), layer) ==
|
|
building)
|
|
size.X++;
|
|
// Search down
|
|
while (grid.GetBuildingAtCell(new Vector2I(checkCell.X, checkCell.Y + size.Y), layer) ==
|
|
building)
|
|
size.Y++;
|
|
|
|
// Get rotation from the first cell
|
|
var rotation = 0f; // You'll need to store rotation in GridManager to make this work
|
|
return (checkCell, size, rotation);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
} |