Move around scripts to cleanup the Minigame structure
This commit is contained in:
@@ -0,0 +1,673 @@
|
||||
using System.Collections;
|
||||
using System.Collections.Generic;
|
||||
using UnityEngine;
|
||||
using UnityEngine.Events;
|
||||
using UnityEngine.Serialization;
|
||||
using Pooling;
|
||||
|
||||
namespace Minigames.DivingForPictures
|
||||
{
|
||||
/// <summary>
|
||||
/// Spawns and manages trench wall tiles for the endless descender minigame.
|
||||
/// </summary>
|
||||
public class TrenchTileSpawner : MonoBehaviour
|
||||
{
|
||||
[Header("Tile Prefabs")]
|
||||
[Tooltip("List of possible trench tile prefabs.")]
|
||||
[SerializeField] private List<GameObject> tilePrefabs;
|
||||
|
||||
[Header("Tile Settings")]
|
||||
[SerializeField] private int initialTileCount = 3;
|
||||
[SerializeField] private float tileSpawnBuffer = 1f;
|
||||
|
||||
[Header("Movement Settings")]
|
||||
[SerializeField] private float moveSpeed = 3f;
|
||||
[SerializeField] private float speedUpFactor = 0.2f;
|
||||
[SerializeField] private float speedUpInterval = 10f;
|
||||
[SerializeField] private float maxMoveSpeed = 12f;
|
||||
|
||||
[Header("Object Pooling")]
|
||||
[SerializeField] private bool useObjectPooling = true;
|
||||
[SerializeField] private int maxPerPrefabPoolSize = 2;
|
||||
[SerializeField] private int totalMaxPoolSize = 10;
|
||||
|
||||
[Header("Events")]
|
||||
[FormerlySerializedAs("OnTileSpawned")]
|
||||
public UnityEvent<GameObject> onTileSpawned;
|
||||
|
||||
[FormerlySerializedAs("OnTileDestroyed")]
|
||||
public UnityEvent<GameObject> onTileDestroyed;
|
||||
|
||||
// Private fields
|
||||
private readonly Dictionary<GameObject, float> _tileHeights = new Dictionary<GameObject, float>();
|
||||
private readonly List<GameObject> _activeTiles = new List<GameObject>();
|
||||
private readonly Dictionary<int, int> _tileLastUsed = new Dictionary<int, int>();
|
||||
|
||||
private int _spawnCounter;
|
||||
private float _speedUpTimer;
|
||||
private Camera _mainCamera;
|
||||
private float _screenBottom;
|
||||
private float _screenTop;
|
||||
private TrenchTilePool _tilePool;
|
||||
|
||||
// Current velocity for tile movement
|
||||
private float _currentVelocity;
|
||||
|
||||
// Interval for velocity calculations (seconds)
|
||||
[SerializeField] private float velocityCalculationInterval = 0.5f;
|
||||
|
||||
private const float TileSpawnZ = -1f;
|
||||
private const float DefaultTileHeight = 5f;
|
||||
|
||||
// Direction state
|
||||
private bool _isSurfacing = false;
|
||||
private bool _stopSpawning = false;
|
||||
|
||||
// Event triggered when the last tile leaves the screen after stopping spawning
|
||||
public UnityEvent onLastTileLeft = new UnityEvent();
|
||||
|
||||
// Velocity management
|
||||
private float _baseMoveSpeed;
|
||||
private float _velocityFactor = 1.0f;
|
||||
|
||||
private void Awake()
|
||||
{
|
||||
_mainCamera = Camera.main;
|
||||
_baseMoveSpeed = moveSpeed; // Store the original base speed
|
||||
|
||||
// Calculate tile heights for each prefab
|
||||
CalculateTileHeights();
|
||||
|
||||
// Ensure all prefabs have Tile components
|
||||
ValidateTilePrefabs();
|
||||
|
||||
if (useObjectPooling)
|
||||
{
|
||||
InitializeObjectPool();
|
||||
}
|
||||
}
|
||||
|
||||
// Validate that all prefabs have Tile components
|
||||
private void ValidateTilePrefabs()
|
||||
{
|
||||
for (int i = 0; i < tilePrefabs.Count; i++)
|
||||
{
|
||||
if (tilePrefabs[i] == null) continue;
|
||||
|
||||
// Check if the prefab has a Tile component
|
||||
if (tilePrefabs[i].GetComponent<Tile>() == null)
|
||||
{
|
||||
Debug.LogWarning($"Prefab {tilePrefabs[i].name} does not have a Tile component. Adding one automatically.");
|
||||
// Add the Tile component if it doesn't exist
|
||||
tilePrefabs[i].AddComponent<Tile>();
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private void Start()
|
||||
{
|
||||
CalculateScreenBounds();
|
||||
SpawnInitialTiles();
|
||||
|
||||
// Initialize velocity and start the velocity calculation coroutine
|
||||
_currentVelocity = moveSpeed * Time.fixedDeltaTime;
|
||||
StartCoroutine(VelocityCalculationRoutine());
|
||||
}
|
||||
|
||||
private void Update()
|
||||
{
|
||||
HandleMovement();
|
||||
HandleTileDestruction();
|
||||
HandleTileSpawning();
|
||||
HandleSpeedRamping();
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets the current velocity of the tiles
|
||||
/// </summary>
|
||||
/// <returns>The current upward velocity of the tiles</returns>
|
||||
public float GetCurrentVelocity()
|
||||
{
|
||||
return _currentVelocity;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Sets a custom velocity, overriding the calculated one
|
||||
/// </summary>
|
||||
/// <param name="velocity">The new velocity value</param>
|
||||
public void SetVelocity(float velocity)
|
||||
{
|
||||
_currentVelocity = velocity;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Coroutine that periodically calculates the velocity based on game state
|
||||
/// </summary>
|
||||
private IEnumerator VelocityCalculationRoutine()
|
||||
{
|
||||
while (true)
|
||||
{
|
||||
CalculateVelocity();
|
||||
yield return new WaitForSeconds(velocityCalculationInterval);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Calculates the current velocity based on move speed
|
||||
/// </summary>
|
||||
private void CalculateVelocity()
|
||||
{
|
||||
_currentVelocity = moveSpeed * Time.fixedDeltaTime;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Calculate height values for all tile prefabs
|
||||
/// </summary>
|
||||
private void CalculateTileHeights()
|
||||
{
|
||||
foreach (var prefab in tilePrefabs)
|
||||
{
|
||||
if (prefab == null)
|
||||
{
|
||||
Debug.LogError("Null prefab found in tilePrefabs list!");
|
||||
continue;
|
||||
}
|
||||
|
||||
Renderer renderer = prefab.GetComponentInChildren<Renderer>();
|
||||
if (renderer != null)
|
||||
{
|
||||
_tileHeights[prefab] = renderer.bounds.size.y;
|
||||
}
|
||||
else
|
||||
{
|
||||
// Fallback in case no renderer is found
|
||||
_tileHeights[prefab] = DefaultTileHeight;
|
||||
Debug.LogWarning($"No renderer found in prefab {prefab.name}. Using default height of {DefaultTileHeight}.");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Initialize the object pool system
|
||||
/// </summary>
|
||||
private void InitializeObjectPool()
|
||||
{
|
||||
// Create the tile pool
|
||||
GameObject poolGO = new GameObject("TrenchTilePool");
|
||||
poolGO.transform.SetParent(transform);
|
||||
_tilePool = poolGO.AddComponent<TrenchTilePool>();
|
||||
|
||||
// Set up the pool configuration
|
||||
_tilePool.maxPerPrefabPoolSize = maxPerPrefabPoolSize;
|
||||
_tilePool.totalMaxPoolSize = totalMaxPoolSize;
|
||||
|
||||
// Convert the GameObject list to a Tile list
|
||||
List<Tile> prefabTiles = new List<Tile>(tilePrefabs.Count);
|
||||
foreach (var prefab in tilePrefabs)
|
||||
{
|
||||
if (prefab != null)
|
||||
{
|
||||
Tile tileComponent = prefab.GetComponent<Tile>();
|
||||
if (tileComponent != null)
|
||||
{
|
||||
prefabTiles.Add(tileComponent);
|
||||
}
|
||||
else
|
||||
{
|
||||
Debug.LogError($"Prefab {prefab.name} is missing a Tile component!");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Initialize the pool with the tile component list
|
||||
_tilePool.Initialize(prefabTiles);
|
||||
|
||||
// Periodically trim the pool to optimize memory usage
|
||||
InvokeRepeating(nameof(TrimExcessPooledTiles), 10f, 30f);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Spawn the initial set of tiles
|
||||
/// </summary>
|
||||
private void SpawnInitialTiles()
|
||||
{
|
||||
// Calculate starting Y position - moved 2 tiles up from the bottom of the screen
|
||||
float startingY = _screenBottom;
|
||||
|
||||
// If we have prefab tiles with known heights, use their average height for offset calculation
|
||||
float tileHeightEstimate = DefaultTileHeight;
|
||||
if (tilePrefabs != null && tilePrefabs.Count > 0 && tilePrefabs[0] != null)
|
||||
{
|
||||
if (_tileHeights.TryGetValue(tilePrefabs[0], out float height))
|
||||
{
|
||||
tileHeightEstimate = height;
|
||||
}
|
||||
}
|
||||
|
||||
// Move starting position up by 2 tile heights
|
||||
startingY += tileHeightEstimate * 2;
|
||||
|
||||
for (int i = 0; i < initialTileCount; i++)
|
||||
{
|
||||
float y = startingY;
|
||||
// Calculate proper Y position based on previous tiles
|
||||
if (i > 0 && _activeTiles.Count > 0)
|
||||
{
|
||||
GameObject prevTile = _activeTiles[_activeTiles.Count - 1];
|
||||
float prevHeight = GetTileHeight(prevTile);
|
||||
y = prevTile.transform.position.y - prevHeight;
|
||||
}
|
||||
SpawnTileAtY(y);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Calculate the screen bounds in world space
|
||||
/// </summary>
|
||||
private void CalculateScreenBounds()
|
||||
{
|
||||
if (_mainCamera == null)
|
||||
{
|
||||
_mainCamera = Camera.main;
|
||||
if (_mainCamera == null)
|
||||
{
|
||||
Debug.LogError("No main camera found!");
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
Vector3 bottom = _mainCamera.ViewportToWorldPoint(new Vector3(0.5f, 0f, _mainCamera.nearClipPlane));
|
||||
Vector3 top = _mainCamera.ViewportToWorldPoint(new Vector3(0.5f, 1f, _mainCamera.nearClipPlane));
|
||||
_screenBottom = bottom.y;
|
||||
_screenTop = top.y;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Called when the velocity factor changes from the DivingGameManager
|
||||
/// </summary>
|
||||
public void OnVelocityFactorChanged(float velocityFactor)
|
||||
{
|
||||
_velocityFactor = velocityFactor;
|
||||
|
||||
// Update the actual move speed based on the velocity factor
|
||||
// This keeps the original move speed intact for game logic
|
||||
moveSpeed = _baseMoveSpeed * Mathf.Abs(_velocityFactor);
|
||||
|
||||
// Recalculate velocity immediately
|
||||
CalculateVelocity();
|
||||
|
||||
Debug.Log($"[TrenchTileSpawner] Velocity factor updated to {_velocityFactor:F2}, moveSpeed: {moveSpeed:F2}");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Reverses direction to start surfacing
|
||||
/// </summary>
|
||||
public void StartSurfacing()
|
||||
{
|
||||
if (_isSurfacing) return; // Already surfacing
|
||||
|
||||
// Set surfacing flag for spawn/despawn logic
|
||||
_isSurfacing = true;
|
||||
|
||||
// Reverse the active tiles array to maintain consistent indexing logic
|
||||
_activeTiles.Reverse();
|
||||
|
||||
Debug.Log("[TrenchTileSpawner] Started surfacing - reversed array order");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Stops spawning new tiles
|
||||
/// </summary>
|
||||
public void StopSpawning()
|
||||
{
|
||||
_stopSpawning = true;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Handles the movement of all active tiles based on the current velocity
|
||||
/// </summary>
|
||||
private void HandleMovement()
|
||||
{
|
||||
foreach (var tile in _activeTiles)
|
||||
{
|
||||
if (tile != null)
|
||||
{
|
||||
// Use velocity factor to determine direction
|
||||
Vector3 direction = Vector3.up * Mathf.Sign(_velocityFactor);
|
||||
float speed = _currentVelocity;
|
||||
|
||||
// Apply movement
|
||||
tile.transform.position += direction * speed;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Check for tiles that have moved off screen and should be destroyed or returned to pool
|
||||
/// </summary>
|
||||
private void HandleTileDestruction()
|
||||
{
|
||||
if (_activeTiles.Count == 0) return;
|
||||
|
||||
GameObject topTile = _activeTiles[0];
|
||||
if (topTile == null)
|
||||
{
|
||||
_activeTiles.RemoveAt(0);
|
||||
return;
|
||||
}
|
||||
|
||||
float tileHeight = GetTileHeight(topTile);
|
||||
|
||||
bool shouldDestroy;
|
||||
if (_isSurfacing)
|
||||
{
|
||||
// When surfacing, destroy tiles at the bottom
|
||||
shouldDestroy = topTile.transform.position.y + tileHeight / 2 < _screenBottom - tileSpawnBuffer;
|
||||
}
|
||||
else
|
||||
{
|
||||
// When descending, destroy tiles at the top
|
||||
shouldDestroy = topTile.transform.position.y - tileHeight / 2 > _screenTop + tileSpawnBuffer;
|
||||
}
|
||||
|
||||
if (shouldDestroy)
|
||||
{
|
||||
_activeTiles.RemoveAt(0);
|
||||
onTileDestroyed?.Invoke(topTile);
|
||||
|
||||
if (useObjectPooling && _tilePool != null)
|
||||
{
|
||||
// Find the prefab index for this tile
|
||||
int prefabIndex = GetPrefabIndex(topTile);
|
||||
if (prefabIndex >= 0)
|
||||
{
|
||||
_tilePool.ReturnTile(topTile, prefabIndex);
|
||||
}
|
||||
else
|
||||
{
|
||||
Destroy(topTile);
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
Destroy(topTile);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Check if new tiles need to be spawned
|
||||
/// </summary>
|
||||
private void HandleTileSpawning()
|
||||
{
|
||||
if (_activeTiles.Count == 0)
|
||||
{
|
||||
// If we have no active tiles and spawning is stopped, trigger the event
|
||||
if (_stopSpawning)
|
||||
{
|
||||
onLastTileLeft.Invoke();
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
GameObject bottomTile = _activeTiles[^1];
|
||||
if (bottomTile == null)
|
||||
{
|
||||
_activeTiles.RemoveAt(_activeTiles.Count - 1);
|
||||
return;
|
||||
}
|
||||
|
||||
// Get the tile height once to use in all calculations
|
||||
float tileHeight = GetTileHeight(bottomTile);
|
||||
|
||||
// If we're in stop spawning mode, don't spawn new tiles
|
||||
if (_stopSpawning)
|
||||
{
|
||||
// Check if this is the last tile, and if it's about to leave the screen
|
||||
if (_activeTiles.Count == 1)
|
||||
{
|
||||
bool isLastTileLeaving;
|
||||
|
||||
if (_isSurfacing)
|
||||
{
|
||||
// When surfacing, check if the bottom of the tile is above the top of the screen
|
||||
isLastTileLeaving = bottomTile.transform.position.y - tileHeight / 2 > _screenTop + tileSpawnBuffer;
|
||||
}
|
||||
else
|
||||
{
|
||||
// When descending, check if the top of the tile is below the bottom of the screen
|
||||
isLastTileLeaving = bottomTile.transform.position.y + tileHeight / 2 < _screenBottom - tileSpawnBuffer;
|
||||
}
|
||||
|
||||
if (isLastTileLeaving)
|
||||
{
|
||||
onLastTileLeft.Invoke();
|
||||
}
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
bool shouldSpawn;
|
||||
float newY;
|
||||
|
||||
if (_isSurfacing)
|
||||
{
|
||||
// When surfacing, spawn new tiles at the top
|
||||
float topEdge = bottomTile.transform.position.y + tileHeight / 2;
|
||||
shouldSpawn = topEdge < _screenTop + tileSpawnBuffer;
|
||||
newY = bottomTile.transform.position.y + tileHeight;
|
||||
}
|
||||
else
|
||||
{
|
||||
// When descending, spawn new tiles at the bottom
|
||||
float bottomEdge = bottomTile.transform.position.y - tileHeight / 2;
|
||||
shouldSpawn = bottomEdge > _screenBottom - tileSpawnBuffer;
|
||||
newY = bottomTile.transform.position.y - tileHeight;
|
||||
}
|
||||
|
||||
if (shouldSpawn)
|
||||
{
|
||||
SpawnTileAtY(newY);
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Handle increasing the movement speed over time
|
||||
/// </summary>
|
||||
private void HandleSpeedRamping()
|
||||
{
|
||||
_speedUpTimer += Time.deltaTime;
|
||||
if (_speedUpTimer >= speedUpInterval)
|
||||
{
|
||||
moveSpeed = Mathf.Min(moveSpeed + speedUpFactor, maxMoveSpeed);
|
||||
_speedUpTimer = 0f;
|
||||
}
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Spawn a new tile at the specified Y position
|
||||
/// </summary>
|
||||
/// <param name="y">The Y position to spawn at</param>
|
||||
private void SpawnTileAtY(float y)
|
||||
{
|
||||
if (tilePrefabs == null || tilePrefabs.Count == 0)
|
||||
{
|
||||
Debug.LogError("No tile prefabs available for spawning!");
|
||||
return;
|
||||
}
|
||||
|
||||
int prefabIndex = GetWeightedRandomTileIndex();
|
||||
GameObject prefab = tilePrefabs[prefabIndex];
|
||||
if (prefab == null)
|
||||
{
|
||||
Debug.LogError($"Tile prefab at index {prefabIndex} is null!");
|
||||
return;
|
||||
}
|
||||
|
||||
GameObject tile;
|
||||
|
||||
if (useObjectPooling && _tilePool != null)
|
||||
{
|
||||
tile = _tilePool.GetTile(prefabIndex);
|
||||
if (tile == null)
|
||||
{
|
||||
Debug.LogError("Failed to get tile from pool!");
|
||||
return;
|
||||
}
|
||||
|
||||
tile.transform.position = new Vector3(0f, y, TileSpawnZ);
|
||||
tile.transform.rotation = prefab.transform.rotation;
|
||||
tile.transform.SetParent(transform);
|
||||
}
|
||||
else
|
||||
{
|
||||
// Use the prefab's original rotation
|
||||
tile = Instantiate(prefab, new Vector3(0f, y, TileSpawnZ), prefab.transform.rotation, transform);
|
||||
}
|
||||
|
||||
_activeTiles.Add(tile);
|
||||
_tileLastUsed[prefabIndex] = _spawnCounter++;
|
||||
onTileSpawned?.Invoke(tile);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets a weighted random tile index, favoring tiles that haven't been used recently
|
||||
/// </summary>
|
||||
/// <returns>The selected prefab index</returns>
|
||||
private int GetWeightedRandomTileIndex()
|
||||
{
|
||||
int prefabCount = tilePrefabs.Count;
|
||||
List<float> weights = new List<float>(prefabCount);
|
||||
|
||||
for (int i = 0; i < prefabCount; i++)
|
||||
{
|
||||
int lastUsed = _tileLastUsed.TryGetValue(i, out var value) ? value : -prefabCount;
|
||||
int age = _spawnCounter - lastUsed;
|
||||
float weight = Mathf.Clamp(age, 1, prefabCount * 2); // More unused = higher weight
|
||||
weights.Add(weight);
|
||||
}
|
||||
|
||||
float totalWeight = 0f;
|
||||
foreach (var weight in weights)
|
||||
{
|
||||
totalWeight += weight;
|
||||
}
|
||||
|
||||
float randomValue = Random.value * totalWeight;
|
||||
for (int i = 0; i < prefabCount; i++)
|
||||
{
|
||||
if (randomValue < weights[i])
|
||||
{
|
||||
return i;
|
||||
}
|
||||
randomValue -= weights[i];
|
||||
}
|
||||
|
||||
return Random.Range(0, prefabCount); // fallback
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets the height of a tile based on its prefab or renderer bounds
|
||||
/// </summary>
|
||||
/// <param name="tile">The tile to measure</param>
|
||||
/// <returns>The height of the tile</returns>
|
||||
private float GetTileHeight(GameObject tile)
|
||||
{
|
||||
if (tile == null)
|
||||
{
|
||||
Debug.LogWarning("Attempted to get height of null tile!");
|
||||
return DefaultTileHeight;
|
||||
}
|
||||
|
||||
// Check if this is a known prefab
|
||||
foreach (var prefab in tilePrefabs)
|
||||
{
|
||||
if (prefab == null) continue;
|
||||
|
||||
// Check if this tile was created from this prefab
|
||||
if (tile.name.StartsWith(prefab.name))
|
||||
{
|
||||
if (_tileHeights.TryGetValue(prefab, out float height))
|
||||
{
|
||||
return height;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// If not found, calculate it from the renderer
|
||||
Renderer renderer = tile.GetComponentInChildren<Renderer>();
|
||||
if (renderer != null)
|
||||
{
|
||||
return renderer.bounds.size.y;
|
||||
}
|
||||
|
||||
// Fallback
|
||||
return DefaultTileHeight;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Gets the index of the prefab that was used to create this tile
|
||||
/// </summary>
|
||||
/// <param name="tile">The tile to check</param>
|
||||
/// <returns>The index of the prefab or -1 if not found</returns>
|
||||
private int GetPrefabIndex(GameObject tile)
|
||||
{
|
||||
if (tile == null || tilePrefabs == null)
|
||||
{
|
||||
return -1;
|
||||
}
|
||||
|
||||
for (int i = 0; i < tilePrefabs.Count; i++)
|
||||
{
|
||||
if (tilePrefabs[i] == null) continue;
|
||||
|
||||
if (tile.name.StartsWith(tilePrefabs[i].name))
|
||||
{
|
||||
return i;
|
||||
}
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// Called periodically to trim excess pooled tiles
|
||||
/// </summary>
|
||||
private void TrimExcessPooledTiles()
|
||||
{
|
||||
if (_tilePool != null)
|
||||
{
|
||||
_tilePool.TrimExcess();
|
||||
}
|
||||
}
|
||||
|
||||
#if UNITY_EDITOR
|
||||
private void OnDrawGizmosSelected()
|
||||
{
|
||||
if (!Application.isPlaying)
|
||||
{
|
||||
// Only try to calculate this if _screenBottom hasn't been set by the game
|
||||
Camera editorCam = Camera.main;
|
||||
if (editorCam != null)
|
||||
{
|
||||
Vector3 bottom = editorCam.ViewportToWorldPoint(new Vector3(0.5f, 0f, editorCam.nearClipPlane));
|
||||
_screenBottom = bottom.y;
|
||||
}
|
||||
}
|
||||
|
||||
// Draw tile bounds for debugging
|
||||
Gizmos.color = Color.cyan;
|
||||
for (int i = 0; i < initialTileCount; i++)
|
||||
{
|
||||
float height = DefaultTileHeight;
|
||||
if (tilePrefabs != null && tilePrefabs.Count > 0 && tilePrefabs[0] != null &&
|
||||
_tileHeights.TryGetValue(tilePrefabs[0], out float h))
|
||||
{
|
||||
height = h;
|
||||
}
|
||||
Vector3 center = new Vector3(0f, _screenBottom + i * height, 0f);
|
||||
Gizmos.DrawWireCube(center, new Vector3(10f, height, 1f));
|
||||
}
|
||||
}
|
||||
#endif
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user