353 lines
14 KiB
C#
353 lines
14 KiB
C#
using UnityEngine;
|
|
using System.Collections.Generic;
|
|
using System.Collections;
|
|
|
|
namespace SpecialMoveCards
|
|
{
|
|
/// <summary>
|
|
/// Spawns card pickups similar to common pickup systems:
|
|
/// - Maintains a target count of active cards (default 2)
|
|
/// - Spawns at random spawn points or within an area
|
|
/// - When a card is picked up (destroyed), schedules a delayed respawn to keep the target count
|
|
/// </summary>
|
|
public class CardSpawner : MonoBehaviour
|
|
{
|
|
// ========== MASTER DISABLE FLAG ==========
|
|
// Set to TRUE to completely disable the card/special move system
|
|
// This is a quick toggle - you can implement a proper system later
|
|
public static bool CARD_SYSTEM_DISABLED = true;
|
|
// ==========================================
|
|
|
|
private static readonly List<CardSpawner> s_instances = new List<CardSpawner>();
|
|
[Header("Card Prefab & Data")]
|
|
[Tooltip("Generic Card prefab that contains CardBehaviour (used if 'Card Prefabs' list is empty).")]
|
|
public GameObject cardPrefab;
|
|
[Tooltip("If provided, a random prefab from this list will be spawned instead of the single prefab above. Each prefab can carry its own CardData and visuals (e.g., per-color prefabs).")]
|
|
public List<GameObject> cardPrefabs = new List<GameObject>();
|
|
[Tooltip("Pool of possible CardData to spawn from.")]
|
|
public List<CardData> cardPool = new List<CardData>();
|
|
|
|
[Header("Spawning")]
|
|
public List<Transform> spawnPoints = new List<Transform>();
|
|
[Tooltip("If no spawn points, use a box area in local space.")]
|
|
public Vector3 areaSize = new Vector3(10, 0, 10);
|
|
[Tooltip("Number of cards to keep alive concurrently. Typical big-game behavior uses small numbers like 1-2.")]
|
|
public int targetCardsInScene = 2;
|
|
[Tooltip("Random delay before a replacement card is spawned after pickup (x..y seconds).")]
|
|
public Vector2 respawnDelay = new Vector2(2f, 5f);
|
|
[Tooltip("Ensure only one active card per spawn point at a time.")]
|
|
public bool useUniqueSpawnPoints = true;
|
|
|
|
private readonly HashSet<GameObject> alive = new HashSet<GameObject>();
|
|
private readonly Dictionary<int, GameObject> occupiedPoints = new Dictionary<int, GameObject>();
|
|
|
|
private void OnEnable()
|
|
{
|
|
// Skip if card system is disabled
|
|
if (CARD_SYSTEM_DISABLED)
|
|
{
|
|
Debug.Log("[CardSpawner] Card System is DISABLED - skipping initialization");
|
|
return;
|
|
}
|
|
|
|
if (!s_instances.Contains(this)) s_instances.Add(this);
|
|
GameEvents.CardPicked += OnAnyCardPicked;
|
|
MaintainTargetCount();
|
|
}
|
|
|
|
private void OnDisable()
|
|
{
|
|
GameEvents.CardPicked -= OnAnyCardPicked;
|
|
alive.RemoveWhere(go => go == null);
|
|
occupiedPoints.Clear();
|
|
s_instances.Remove(this);
|
|
}
|
|
|
|
private void TrySpawnOnce()
|
|
{
|
|
CleanupDead();
|
|
if (alive.Count >= targetCardsInScene) return;
|
|
// Build disallowed type set to keep two cards different
|
|
HashSet<CardType> disallowed = BuildDisallowedTypes();
|
|
|
|
Vector3 pos;
|
|
Quaternion rot = Quaternion.identity;
|
|
int usedIndex = -1;
|
|
|
|
if (spawnPoints != null && spawnPoints.Count > 0)
|
|
{
|
|
// Choose a free spawn point if required
|
|
int safety = 25;
|
|
int idx = -1;
|
|
while (safety-- > 0)
|
|
{
|
|
int r = Random.Range(0, spawnPoints.Count);
|
|
if (!useUniqueSpawnPoints || !occupiedPoints.ContainsKey(r)) { idx = r; break; }
|
|
}
|
|
if (idx < 0) idx = Random.Range(0, spawnPoints.Count); // fallback
|
|
var t = spawnPoints[idx];
|
|
pos = t.position;
|
|
rot = t.rotation;
|
|
usedIndex = idx;
|
|
}
|
|
else
|
|
{
|
|
Vector3 half = areaSize * 0.5f;
|
|
Vector3 local = new Vector3(
|
|
Random.Range(-half.x, half.x),
|
|
Random.Range(-half.y, half.y),
|
|
Random.Range(-half.z, half.z));
|
|
pos = transform.TransformPoint(local);
|
|
}
|
|
|
|
var go = SpawnCard(pos, rot, disallowed);
|
|
if (go == null) return; // nothing feasible to spawn
|
|
alive.Add(go);
|
|
if (useUniqueSpawnPoints && usedIndex >= 0)
|
|
occupiedPoints[usedIndex] = go;
|
|
|
|
// Track destruction to free spawn point
|
|
var token = go.AddComponent<SpawnedCardToken>();
|
|
token.Init(this, usedIndex);
|
|
}
|
|
|
|
private void OnDrawGizmosSelected()
|
|
{
|
|
if (spawnPoints == null || spawnPoints.Count == 0)
|
|
{
|
|
Gizmos.color = Color.yellow;
|
|
Gizmos.matrix = transform.localToWorldMatrix;
|
|
Gizmos.DrawWireCube(Vector3.zero, areaSize);
|
|
}
|
|
}
|
|
|
|
// --- Enemy-death drops API ---
|
|
/// <summary>
|
|
/// Called by external systems to attempt a drop at a world position with a given probability.
|
|
/// Respects each spawner's targetCardsInScene limit.
|
|
/// </summary>
|
|
public static void TrySpawnOnEnemyDeath(Vector3 position, float chance = 0.25f)
|
|
{
|
|
if (s_instances.Count == 0) return;
|
|
if (Random.value > Mathf.Clamp01(chance)) return;
|
|
|
|
// Pick the first spawner that has capacity
|
|
for (int i = 0; i < s_instances.Count; i++)
|
|
{
|
|
var sp = s_instances[i];
|
|
if (sp == null || !sp.isActiveAndEnabled) continue;
|
|
sp.CleanupDead();
|
|
if (sp.alive.Count < sp.targetCardsInScene)
|
|
{
|
|
sp.SpawnAtPosition(position + Vector3.up * 0.25f, Quaternion.identity);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
private void SpawnAtPosition(Vector3 pos, Quaternion rot)
|
|
{
|
|
// For death-drops, also try to keep existing type different if only one is alive
|
|
var disallowed = BuildDisallowedTypes();
|
|
var go = SpawnCard(pos, rot, disallowed);
|
|
if (go == null) return;
|
|
alive.Add(go);
|
|
var token = go.AddComponent<SpawnedCardToken>();
|
|
token.Init(this, -1); // no spawn point occupancy
|
|
}
|
|
|
|
private void MaintainTargetCount()
|
|
{
|
|
CleanupDead();
|
|
while (alive.Count < targetCardsInScene)
|
|
TrySpawnOnce();
|
|
}
|
|
|
|
private void CleanupDead()
|
|
{
|
|
// Remove destroyed refs and free occupied points
|
|
if (alive.Count == 0) return;
|
|
var toRemove = new List<GameObject>();
|
|
foreach (var go in alive)
|
|
{
|
|
if (go == null) toRemove.Add(go);
|
|
}
|
|
for (int i = 0; i < toRemove.Count; i++)
|
|
alive.Remove(toRemove[i]);
|
|
|
|
// occupiedPoints are freed in NotifyCardDestroyed; this is extra safety if something slipped through
|
|
var free = new List<int>();
|
|
foreach (var kvp in occupiedPoints)
|
|
{
|
|
if (kvp.Value == null) free.Add(kvp.Key);
|
|
}
|
|
for (int i = 0; i < free.Count; i++)
|
|
occupiedPoints.Remove(free[i]);
|
|
}
|
|
|
|
private void OnAnyCardPicked(CardData _)
|
|
{
|
|
// Schedule a replacement after a small random delay like big games do
|
|
float delay = Random.Range(respawnDelay.x, respawnDelay.y);
|
|
StartCoroutine(RespawnDelayed(delay));
|
|
}
|
|
|
|
private IEnumerator RespawnDelayed(float delay)
|
|
{
|
|
yield return new WaitForSeconds(delay);
|
|
MaintainTargetCount();
|
|
}
|
|
|
|
internal void NotifyCardDestroyed(SpawnedCardToken token)
|
|
{
|
|
if (token == null) return;
|
|
// Free occupancy & alive set; spawning replacement happens via CardPicked event or periodic Maintain
|
|
if (token.spawnPointIndex >= 0 && occupiedPoints.ContainsKey(token.spawnPointIndex))
|
|
occupiedPoints.Remove(token.spawnPointIndex);
|
|
alive.Remove(token.gameObject);
|
|
}
|
|
|
|
public class SpawnedCardToken : MonoBehaviour
|
|
{
|
|
private CardSpawner owner;
|
|
internal int spawnPointIndex = -1;
|
|
public void Init(CardSpawner o, int index)
|
|
{
|
|
owner = o; spawnPointIndex = index;
|
|
}
|
|
private void OnDestroy()
|
|
{
|
|
if (owner != null) owner.NotifyCardDestroyed(this);
|
|
}
|
|
}
|
|
|
|
// --- Helper logic to enforce different types when two are present ---
|
|
private HashSet<CardType> BuildDisallowedTypes()
|
|
{
|
|
var disallowed = new HashSet<CardType>();
|
|
// Only enforce strict difference when target is 2 and we currently have exactly 1 alive card
|
|
if (targetCardsInScene == 2 && alive.Count == 1)
|
|
{
|
|
foreach (var go in alive)
|
|
{
|
|
if (go == null) continue;
|
|
var cb = go.GetComponent<CardBehaviour>();
|
|
if (cb != null && cb.Data != null)
|
|
{
|
|
disallowed.Add(cb.Data.type);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
return disallowed;
|
|
}
|
|
|
|
private GameObject SpawnCard(Vector3 pos, Quaternion rot, HashSet<CardType> disallowed)
|
|
{
|
|
bool multiPrefabs = cardPrefabs != null && cardPrefabs.Count > 0;
|
|
if (!multiPrefabs && cardPrefab == null) return null;
|
|
|
|
// Collect prefab capabilities
|
|
var fixedPrefabs = new List<(GameObject prefab, CardType type)>();
|
|
var genericPrefabs = new List<GameObject>();
|
|
|
|
if (multiPrefabs)
|
|
{
|
|
for (int i = 0; i < cardPrefabs.Count; i++)
|
|
{
|
|
var pf = cardPrefabs[i];
|
|
if (pf == null) continue;
|
|
var cb = pf.GetComponent<CardBehaviour>();
|
|
if (cb != null && cb.Data != null)
|
|
fixedPrefabs.Add((pf, cb.Data.type));
|
|
else
|
|
genericPrefabs.Add(pf);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var pf = cardPrefab;
|
|
var cb = pf != null ? pf.GetComponent<CardBehaviour>() : null;
|
|
if (cb != null && cb.Data != null)
|
|
fixedPrefabs.Add((pf, cb.Data.type));
|
|
else if (pf != null)
|
|
genericPrefabs.Add(pf);
|
|
}
|
|
|
|
// Determine feasible types
|
|
var feasibleTypes = new List<CardType>();
|
|
var fixedTypes = new HashSet<CardType>();
|
|
for (int i = 0; i < fixedPrefabs.Count; i++) fixedTypes.Add(fixedPrefabs[i].type);
|
|
foreach (var t in fixedTypes)
|
|
if (!disallowed.Contains(t)) feasibleTypes.Add(t);
|
|
|
|
bool hasGeneric = genericPrefabs.Count > 0;
|
|
if (hasGeneric && cardPool != null && cardPool.Count > 0)
|
|
{
|
|
var poolTypesSet = new HashSet<CardType>();
|
|
for (int i = 0; i < cardPool.Count; i++) poolTypesSet.Add(cardPool[i].type);
|
|
foreach (var t in poolTypesSet)
|
|
{
|
|
if (!disallowed.Contains(t) && !feasibleTypes.Contains(t))
|
|
feasibleTypes.Add(t);
|
|
}
|
|
}
|
|
|
|
// If nothing feasible with disallowed constraint, relax constraint
|
|
if (feasibleTypes.Count == 0)
|
|
{
|
|
foreach (var t in fixedTypes)
|
|
if (!feasibleTypes.Contains(t)) feasibleTypes.Add(t);
|
|
if (hasGeneric && cardPool != null && cardPool.Count > 0)
|
|
{
|
|
var poolTypesSet = new HashSet<CardType>();
|
|
for (int i = 0; i < cardPool.Count; i++) poolTypesSet.Add(cardPool[i].type);
|
|
foreach (var t in poolTypesSet)
|
|
if (!feasibleTypes.Contains(t)) feasibleTypes.Add(t);
|
|
}
|
|
}
|
|
|
|
// Fallback: if still empty (e.g., no pool and only generic prefabs), just spawn any prefab without enforcing type
|
|
if (feasibleTypes.Count == 0)
|
|
{
|
|
GameObject anyPrefab = multiPrefabs ? (cardPrefabs.Count > 0 ? cardPrefabs[Random.Range(0, cardPrefabs.Count)] : null) : cardPrefab;
|
|
if (anyPrefab == null) return null;
|
|
return Instantiate(anyPrefab, pos, rot);
|
|
}
|
|
|
|
// Choose a target type randomly
|
|
var targetType = feasibleTypes[Random.Range(0, feasibleTypes.Count)];
|
|
|
|
// Choose a matching prefab if possible; else a generic prefab
|
|
GameObject chosenPrefab = null;
|
|
var matches = new List<GameObject>();
|
|
for (int i = 0; i < fixedPrefabs.Count; i++)
|
|
if (fixedPrefabs[i].type.Equals(targetType)) matches.Add(fixedPrefabs[i].prefab);
|
|
if (matches.Count > 0)
|
|
chosenPrefab = matches[Random.Range(0, matches.Count)];
|
|
else if (hasGeneric)
|
|
chosenPrefab = genericPrefabs[Random.Range(0, genericPrefabs.Count)];
|
|
else
|
|
chosenPrefab = multiPrefabs ? cardPrefabs[Random.Range(0, cardPrefabs.Count)] : cardPrefab; // last resort
|
|
|
|
var go = Instantiate(chosenPrefab, pos, rot);
|
|
var behaviour = go.GetComponent<CardBehaviour>();
|
|
if (behaviour != null && behaviour.Data == null)
|
|
{
|
|
// Assign data matching chosen type
|
|
CardData assign = null;
|
|
if (cardPool != null && cardPool.Count > 0)
|
|
{
|
|
// collect indices with targetType
|
|
var idxs = new List<int>();
|
|
for (int i = 0; i < cardPool.Count; i++) if (cardPool[i].type.Equals(targetType)) idxs.Add(i);
|
|
if (idxs.Count > 0) assign = cardPool[idxs[Random.Range(0, idxs.Count)]];
|
|
else assign = cardPool[Random.Range(0, cardPool.Count)];
|
|
}
|
|
if (assign != null) behaviour.SetData(assign);
|
|
}
|
|
return go;
|
|
}
|
|
}
|
|
}
|