using System.Collections;
|
using System.Collections.Generic;
|
using UnityEngine;
|
|
public class BackgroundManager : MonoBehaviour
|
{
|
[System.Serializable]
|
public class BackgroundLayer
|
{
|
public float yThreshold;
|
public Sprite backgroundSprite;
|
public float transitionDistance = 3f; // Distance over which the transition occurs
|
[Range(0f, 1f)] public float parallaxEffect = 0.5f;
|
}
|
|
[SerializeField] private SpriteRenderer spriteRenderer;
|
[SerializeField] private BackgroundLayer[] backgroundLayers;
|
[SerializeField] private Transform playerTransform; // Add this field
|
[SerializeField] private float tileBuffer = 1f; // Extra tiles beyond camera view
|
private bool isTransitioning = false; // Add this field
|
|
private Transform cameraTransform;
|
private Vector3 lastCameraPosition;
|
private int currentLayerIndex = 0;
|
private int lastLayerIndex = 0;
|
private float startPositionX;
|
private float startPositionY;
|
|
private float lastUpdatePlayerY = 0f; // Track the last Y position of the player
|
private bool isMovingUp = false; // Track if the player is moving up
|
|
private Dictionary<Vector2Int, SpriteRenderer> backgroundTiles = new Dictionary<Vector2Int, SpriteRenderer>();
|
private Dictionary<Vector2Int, SpriteRenderer> transitionTiles = new Dictionary<Vector2Int, SpriteRenderer>();
|
private Vector2 tileSize;
|
private Camera mainCamera;
|
|
private void Start()
|
{
|
mainCamera = Camera.main;
|
cameraTransform = mainCamera.transform;
|
lastCameraPosition = cameraTransform.position;
|
|
if (spriteRenderer == null)
|
spriteRenderer = GetComponent<SpriteRenderer>();
|
|
if (backgroundLayers != null && backgroundLayers.Length > 0)
|
{
|
Sprite firstSprite = backgroundLayers[0].backgroundSprite;
|
tileSize = new Vector2(firstSprite.bounds.size.x, firstSprite.bounds.size.y);
|
}
|
// Set initial background based on player position
|
if (backgroundLayers != null && backgroundLayers.Length > 0)
|
{
|
float playerY = playerTransform.position.y;
|
int initialLayerIndex = 0;
|
|
// Find the correct background layer for the player's position
|
for (int i = 0; i < backgroundLayers.Length; i++)
|
{
|
if (playerY > backgroundLayers[i].yThreshold)
|
{
|
initialLayerIndex = i;
|
break;
|
}
|
}
|
|
spriteRenderer.sprite = backgroundLayers[initialLayerIndex].backgroundSprite;
|
currentLayerIndex = initialLayerIndex;
|
lastLayerIndex = currentLayerIndex;
|
}
|
InitializeInitialTiles();
|
|
startPositionX = playerTransform.position.x;
|
startPositionY = playerTransform.position.y;
|
}
|
private void InitializeInitialTiles()
|
{
|
// Calculate visible area
|
float cameraHeight = 2f * mainCamera.orthographicSize;
|
float cameraWidth = cameraHeight * mainCamera.aspect;
|
|
// Calculate number of tiles needed
|
int horizontalTiles = Mathf.CeilToInt(cameraWidth / tileSize.x) + 2;
|
int verticalTiles = Mathf.CeilToInt(cameraHeight / tileSize.y) + 2;
|
|
// Create initial grid of tiles
|
for (int x = -horizontalTiles; x <= horizontalTiles; x++)
|
{
|
for (int y = -verticalTiles; y <= verticalTiles; y++)
|
{
|
CreateTile(new Vector2Int(x, y));
|
}
|
}
|
}
|
|
private void CreateTile(Vector2Int gridPosition)
|
{
|
if (backgroundTiles.ContainsKey(gridPosition))
|
return;
|
|
GameObject tileObj = new GameObject($"Tile_{gridPosition.x}_{gridPosition.y}");
|
tileObj.transform.parent = transform;
|
|
SpriteRenderer tileSR = tileObj.AddComponent<SpriteRenderer>();
|
tileSR.sprite = backgroundLayers[currentLayerIndex].backgroundSprite;
|
tileSR.sortingOrder = spriteRenderer.sortingOrder;
|
tileSR.sortingLayerName = spriteRenderer.sortingLayerName;
|
|
// Position the tile
|
Vector3 position = new Vector3(
|
gridPosition.x * tileSize.x,
|
gridPosition.y * tileSize.y,
|
transform.position.z
|
);
|
tileObj.transform.localPosition = position;
|
tileObj.transform.localScale = Vector3.one; // Match scale
|
|
backgroundTiles.Add(gridPosition, tileSR);
|
}
|
|
private void Update()
|
{
|
UpdateTiles();
|
// Calculate parallax movement
|
Vector3 cameraDelta = cameraTransform.position - lastCameraPosition;
|
Vector3 newPosition = transform.position;
|
|
// Update X position with parallax
|
float parallaxX = (cameraTransform.position.x - startPositionX) * GetCurrentParallaxEffect();
|
newPosition.x = startPositionX + parallaxX;
|
|
// Update Y position to follow camera
|
float parallaxY = (cameraTransform.position.y - startPositionY) * GetCurrentParallaxEffect();
|
newPosition.y = startPositionY + parallaxY;
|
|
transform.position = newPosition;
|
|
// Check for background change
|
float currentY = playerTransform.position.y;
|
int newLayerIndex = currentLayerIndex;
|
|
for (int i = 0; i < backgroundLayers.Length; i++)
|
{
|
if (currentY > backgroundLayers[i].yThreshold)
|
{
|
newLayerIndex = i;
|
break;
|
}
|
}
|
|
if (newLayerIndex != currentLayerIndex && !isTransitioning) // Add transition check
|
{
|
StartCoroutine(TransitionBackground(backgroundLayers[newLayerIndex]));
|
currentLayerIndex = newLayerIndex;
|
}
|
|
lastCameraPosition = cameraTransform.position;
|
float lastUpdatePlayerYRounded = Mathf.Round(lastUpdatePlayerY * 10) / 10;
|
float playerYRounded = Mathf.Round(playerTransform.position.y * 10) / 10;
|
if (lastUpdatePlayerYRounded != playerYRounded) // Check if player has moved
|
{
|
if (lastUpdatePlayerYRounded > playerYRounded) // Check if player is moving down
|
{
|
isMovingUp = false;
|
}
|
else if (lastUpdatePlayerYRounded < playerYRounded) // Check if player is moving up
|
{
|
isMovingUp = true;
|
}
|
lastUpdatePlayerY = playerYRounded; // Update the last Y position
|
}
|
|
}
|
private void UpdateTiles()
|
{
|
// Calculate visible area with buffer
|
float cameraHeight = 2f * mainCamera.orthographicSize * (1f + tileBuffer);
|
float cameraWidth = cameraHeight * mainCamera.aspect * (1f + tileBuffer);
|
|
// Calculate parallax offset
|
float parallaxX = (cameraTransform.position.x - startPositionX) * GetCurrentParallaxEffect();
|
float parallaxY = (cameraTransform.position.y - startPositionY) * GetCurrentParallaxEffect();
|
|
// Calculate grid positions that should be visible
|
Vector2 cameraPos = mainCamera.transform.position;
|
|
// Adjust the buffer based on parallax effect
|
float parallaxBuffer = 1f; // Base buffer size
|
float effectiveBuffer = parallaxBuffer * (1f + GetCurrentParallaxEffect());
|
|
int minX = Mathf.FloorToInt((parallaxX - (cameraWidth / 2 * effectiveBuffer)) / tileSize.x);
|
int maxX = Mathf.CeilToInt((parallaxX + (cameraWidth / 2 * effectiveBuffer)) / tileSize.x);
|
int minY = Mathf.FloorToInt((parallaxY - (cameraHeight / 2 * effectiveBuffer)) / tileSize.y);
|
int maxY = Mathf.CeilToInt((parallaxY + (cameraHeight / 2 * effectiveBuffer)) / tileSize.y);
|
|
// Create new tiles
|
for (int x = minX; x <= maxX; x++)
|
{
|
for (int y = minY; y <= maxY; y++)
|
{
|
CreateTile(new Vector2Int(x, y));
|
}
|
}
|
|
// Remove out-of-view tiles
|
List<Vector2Int> tilesToRemove = new List<Vector2Int>();
|
foreach (var tile in backgroundTiles)
|
{
|
if (tile.Key.x < minX - 1 || tile.Key.x > maxX + 1 ||
|
tile.Key.y < minY - 1 || tile.Key.y > maxY + 1)
|
{
|
tilesToRemove.Add(tile.Key);
|
}
|
}
|
|
foreach (var tilePos in tilesToRemove)
|
{
|
if (!transitionTiles.ContainsKey(tilePos))
|
{
|
Destroy(backgroundTiles[tilePos].gameObject);
|
backgroundTiles.Remove(tilePos);
|
}
|
}
|
}
|
|
private float GetCurrentParallaxEffect()
|
{
|
if (backgroundLayers == null || backgroundLayers.Length == 0)
|
return 0.5f;
|
return backgroundLayers[currentLayerIndex].parallaxEffect;
|
}
|
|
private IEnumerator TransitionBackground(BackgroundLayer newLayer)
|
{
|
if (isTransitioning || newLayer.backgroundSprite.name == backgroundLayers[lastLayerIndex].backgroundSprite.name)
|
yield break;
|
|
isTransitioning = true;
|
bool initialMovingUp = isMovingUp;
|
float initialY = playerTransform.position.y;
|
|
// Create transition renderers for all existing tiles
|
foreach (var tile in backgroundTiles)
|
{
|
GameObject transObj = new GameObject($"TransitionTile_{tile.Key.x}_{tile.Key.y}");
|
transObj.transform.parent = transform;
|
transObj.transform.localPosition = tile.Value.transform.localPosition + new Vector3(0, 0, -0.1f);
|
transObj.transform.localScale = Vector3.one;
|
|
SpriteRenderer transSR = transObj.AddComponent<SpriteRenderer>();
|
transSR.sprite = newLayer.backgroundSprite;
|
transSR.sortingOrder = tile.Value.sortingOrder + 1;
|
transSR.sortingLayerName = tile.Value.sortingLayerName;
|
transSR.color = new Color(1, 1, 1, 0);
|
|
transitionTiles.Add(tile.Key, transSR);
|
}
|
|
// Fade in new sprites over old ones
|
while (true)
|
{
|
float currentY = playerTransform.position.y;
|
|
// Check if direction changed
|
if (initialMovingUp != isMovingUp &&
|
((initialMovingUp ? initialY > currentY : initialY < currentY)))
|
{
|
foreach (var transTile in transitionTiles.Values)
|
{
|
Destroy(transTile.gameObject);
|
}
|
transitionTiles.Clear();
|
isTransitioning = false;
|
yield break;
|
}
|
|
// Calculate alpha
|
float alpha = Mathf.Abs(currentY - initialY) / newLayer.transitionDistance;
|
Color newColor = new Color(1, 1, 1, Mathf.Clamp01(alpha));
|
|
// Update all transition tiles
|
foreach (var transTile in transitionTiles.Values)
|
{
|
transTile.color = newColor;
|
}
|
|
if (alpha >= 1f)
|
break;
|
|
yield return null;
|
}
|
|
// Switch sprites on all tiles
|
foreach (var tile in backgroundTiles.Values)
|
{
|
tile.sprite = newLayer.backgroundSprite;
|
}
|
|
// Cleanup transition tiles
|
foreach (var transTile in transitionTiles.Values)
|
{
|
Destroy(transTile.gameObject);
|
}
|
transitionTiles.Clear();
|
|
isTransitioning = false;
|
lastLayerIndex = currentLayerIndex;
|
}
|
}
|
