Imagine um mundo de fantasia onde inimigos aterrorizantes surgem continuamente para desafiar os heróis. A cada momento, novos monstros aparecem na cena, aguardando sua vez de atacar. Essa organização precisa é gerenciada por uma estrutura de dados conhecida como fila (queue).

Uma fila é uma estrutura de dados linear que segue o princípio FIFO (First In, First Out). Isso significa que o primeiro elemento a entrar na fila é o primeiro a sair, assim como em uma fila de pessoas esperando para serem atendidas em um banco. A primeira pessoa a entrar na fila é a primeira a ser atendida, garantindo uma ordem justa e organizada.

No mundo dos jogos, a fila é essencial para manter a ordem dos eventos, como o surgimento de inimigos. Graças à fila, os monstros surgem de maneira estruturada e previsível, permitindo que o fluxo do jogo seja equilibrado e que os jogadores possam se preparar adequadamente para cada batalha.

Características Principais:

1. FIFO (First In, First Out): O primeiro inimigo a entrar na fila é o primeiro a atacar.
2. Operações Básicas:
   • Enqueue: Adiciona um inimigo ao final da fila.
   • Dequeue: Remove e retorna o inimigo no início da fila.
   • Peek: (opcional) Dá uma olhada no inimigo no início da fila sem removê-lo

Exemplo de Implementação em C#

Classe SimpleQueue<T>

A SimpleQueue<T> é uma implementação genérica de uma fila (queue) que utiliza uma lista (List<T>) como estrutura subjacente para armazenar os elementos. A classe oferece operações básicas de uma fila: enfileirar (enqueue), desenfileirar (dequeue), verificar o tamanho (count) e espiar (peek) o próximo elemento.

Atributos:

  
 private List<T> elemetns = new List<T>(); 

• elements: Esta é a lista que armazena os elementos da fila. Usamos uma lista (List<T>) porque ela nos permite adicionar e remover elementos facilmente.

Métodos:

Enqueue(T item)

public void Enqueue(T item)
{
elemetns.Add(item);
}

• Descrição: Este método adiciona um novo elemento ao final da fila.
• Parâmetros: T item – O elemento a ser adicionado à fila.
• Implementação: Usa o método Add da lista para adicionar o item ao final da lista elements.

Dequeue()

</pre>
public T Dequeue()
{
if (elemetns.Count == 0)
{ return default(T); }
T item = elemetns[0];
elemetns.RemoveAt(0);
return item;
}

• Descrição: Este método remove e retorna o primeiro elemento da fila.
• Retorno: T – O primeiro elemento da fila. Se a fila estiver vazia, retorna o valor padrão do tipo T.
• Implementação:
  • Primeiro, verifica se a fila está vazia (elements.Count == 0). Se estiver, retorna default(T), que é o valor padrão do tipo T (por exemplo, 0 para int, null para tipos de referência).
  • Se a fila não estiver vazia, captura o primeiro elemento (elements[0]), remove-o da lista (elements.RemoveAt(0)) e retorna o elemento capturado.

Count()

public int Count() 
{
return elemetns.Count;
}

• Descrição: Este método retorna o número de elementos na fila.
• Retorno: int – O número de elementos atualmente na fila.
• Implementação: Retorna o valor da propriedade Count da lista elements.

Peek()

</pre>
public T Peek()
{
if (elements.Count == 0)
return default(T);

return elements[0];
}
<pre>

• Descrição: Este método retorna o primeiro elemento da fila sem removê-lo.
• Retorno: T – O primeiro elemento da fila. Se a fila estiver vazia, retorna o valor padrão do tipo T.
• Implementação:
  • Verifica se a fila está vazia (elements.Count == 0). Se estiver, retorna default(T).
  • Se a fila não estiver vazia, retorna o primeiro elemento (elements[0]) sem removê-lo.

Resumo

A SimpleQueue<T> é uma implementação genérica de uma fila que oferece as seguintes operações:

1. Enqueue(T item): Adiciona um elemento ao final da fila.
2. Dequeue(): Remove e retorna o primeiro elemento da fila.
3. Count(): Retorna o número de elementos na fila.
4. Peek(): Retorna o primeiro elemento da fila sem removê-lo.

Esta implementação usa uma lista (List<T>) para armazenar os elementos, o que facilita a adição e remoção de itens, mas pode não ser a implementação mais eficiente para filas muito grandes devido ao custo de remoção do primeiro elemento (que requer o deslocamento dos elementos subsequentes). Para usos básicos e moderados, no entanto, esta implementação é simples e eficaz.

Aplicação

Para utilizar a classe de Fila (Queue) , vamos instanciar os inimigos conforme adicionados na FILA.

Exemplo de Uso: Spawn de Inimigos

Vamos criar uma fila para instanciar os inimigos que aparecem no jogo:

using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class SpawnManager : MonoBehaviour
{
public GameObject[] enemyPrefabs; // Array para armazenar os diferentes tipos de inimigos
private SimpleQueue<GameObject> spawnQueue;

// Start is called before the first frame update
void Start()
{
spawnQueue = new SimpleQueue<GameObject>();
EnqueueSpawns();
StartCoroutine(SpawnEnemies());

}

void EnqueueSpawns()
{
// Adiciona os inimigos à fila para serem spawnados
foreach (GameObject enemy in enemyPrefabs)
{
spawnQueue.Enqueue(enemy);
}
}

IEnumerator SpawnEnemies()
{
while (true)
{
if (spawnQueue.Count() > 0)
{
GameObject enemyToSpawn = spawnQueue.Dequeue();
GameObject spawnedEnemy = SpawnEnemy(enemyToSpawn);
yield return new WaitForSeconds(2); // Espera 2 segundos antes de spawnar o próximo inimigo
spawnQueue.Enqueue(enemyToSpawn); // Reenfileira o inimigo para ser spawnado novamente
yield return new WaitForSeconds(3); // Tempo que o inimigo ficará ativo na cena
RemoveEnemy(spawnedEnemy); // Remove o inimigo da cena
}
else
{
yield return null;
}
}
}

GameObject SpawnEnemy(GameObject enemy)
{
Vector3 spawnPosition = new Vector3(Random.Range(-8f, 8f), Random.Range(-4f, 4f), 0);
GameObject spawnedEnemy = Instantiate(enemy, spawnPosition, Quaternion.identity);

return spawnedEnemy;
}

void RemoveEnemy(GameObject enemy)
{

Destroy(enemy);
}
}

Exemplo

Conclusão

Uma fila é uma estrutura de dados essencial para gerenciar sequências de eventos em jogos. Ela garante que os inimigos apareçam de maneira ordenada, criando um fluxo de jogo previsível e equilibrado, onde os jogadores podem se preparar para cada batalha de forma justa e estruturada. Estude Fila!