public class Snake {
    private LinkedList<Coordinate> body;
    private Direction direction;
    private final int startLength;

    public Snake(int startLength){
        this.body = new LinkedList<>();
        this.startLength = startLength;
        this.direction = Direction.LEFT;
        initializeSnake();
    }

    //Positions the snake at the center of the grid
    private void initializeSnake() {
        int middleColumn = GameConfig.COLUMNS / 2;
        int middleRow = GameConfig.ROWS / 2;

        for (int i = 0; i < startLength; i++) {
            Coordinate bodyPart = new Coordinate(middleColumn + i, middleRow);
            body.add(bodyPart);
        }
    }

    //Moves the snake by changing its coordinates starting from the end to previous coordinates of the snake.
    //E.x.Coordinate of the tail is changed to the coordinate of the previous to the tail element
    public void moveSnake(){
        for (int i = body.size() - 1; i > 0; i--) {
            body.get(i).setX(body.get(i - 1).getX());
            body.get(i).setY(body.get(i - 1).getY());
        }

        Coordinate head = getHead();
        head.setX(head.getX() + direction.getX());
        head.setY(head.getY() + direction.getY());

        wrapAround(head);
    }

    //Does not allow the snake to go beyond the edges by checking the position of the head. If the head's coordinate x or y
    //greater than amount of rows or columns, respectively, it moves the head to the mirrored corresponding side on the grid.
    public void wrapAround(Coordinate head){
        if (head.getX() >= GameConfig.COLUMNS) {
            head.setX(0);
        } else if (head.getX() < 0) {
            head.setX(GameConfig.COLUMNS - 1);
        }
        if (head.getY() >= GameConfig.ROWS) {
            head.setY(0);
        } else if (head.getY() < 0) {
            head.setY(GameConfig.ROWS - 1);
        }
    }

    //Checks if the snake head coordinate is the same as an element of the snake body
    public boolean isCollidedWithItself(){
        boolean isCollidedWithItself = false;
        Coordinate snakeHead = getHead();
        for(int i = 1; i < body.size(); i++){
            if(snakeHead.equals(body.get(i))){
                isCollidedWithItself = true;
            }
        }
        return isCollidedWithItself;
    }

    //Plays the music when direction has been changed, does not allow to go in opposite to the current direction
    public void changeDirection(KeyCode keyCode) {
        Direction currentDirection = direction;
        Direction newDirection = direction.getDirectionFromKeyCode(keyCode, direction);
        if (newDirection != currentDirection.getOpposite()) {
            this.direction = newDirection;
            SoundPlayer.getInstance().playSFX(
                    Sounds.ROTATE_1,
                    Sounds.ROTATE_2,
                    Sounds.ROTATE_3,
                    Sounds.ROTATE_4);
        }
    }

    //Since the head of the snake is an image, we need to rotate it when the snake changes direction
    public int determineHeadRotation(){
        return switch (direction) {
            case UP -> 180;
            case DOWN -> 0;
            case LEFT -> 90;
            case RIGHT -> -90;
        };
    }

    //Since the tail of the snake is an image, we need to rotate it when the snake changes direction
    public int determineTailRotation(){
        Coordinate tail = body.get(body.size() - 1);
        Coordinate lastBody = body.get(body.size() - 2);

        if(tail.getX() == lastBody.getX()) {
            if (tail.getY() > lastBody.getY()) {
                return 0;
            } else {
                return 180;
            }
        } else if(tail.getY() == lastBody.getY()) {
            if (tail.getX() > lastBody.getX()) {
                return -90;
            } else {
                return 90;
            }
        }
        return 0;
    }

    //Increases the length by adding new coordinate at the tail
    public void grow(){
        Coordinate tail = getTail();
        Coordinate segment = new Coordinate(tail.getX(), tail.getY());
        body.add(segment);
    }

    //Checks if the coordinate given is not currently on the snake body
    public boolean containsCoordinate(Coordinate coordinate){
        for(Coordinate cord : body){
            if(cord.equals(coordinate)){
                return true;
            }
        }
        return false;
    }

    public LinkedList<Coordinate> getBody(){
        return this.body;
    }

    public Coordinate getHead(){
        return this.body.getFirst();
    }

    public Coordinate getTail(){return this.body.getLast();}
}

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

public class SoundManager : MonoBehaviour
{
    public static SoundManager Instance;
    public AudioSource source;
    public AudioSource musicSource;

    public float musicVolume;
    public float sfxVolume;

    private Dictionary<SFX, AudioClip> sfxClips;
    private Dictionary<MUSIC, AudioClip> musicClips;

    private float currentMusicTime = 0f;
    private bool hasPlayedIntro = false;

    public enum SFX
    {
        Collectible1,
        Collectible2,
        Damage1,
        Damage2,
        Death,
        LunarHawk,
        MenuSelect
    }

    public enum MUSIC
    {
        Menu,
        GameIntro,
        MainLoop
    }

    private void Awake()
    {
        if (Instance == null)
        {
            Instance = this;
            DontDestroyOnLoad(gameObject);
            CreateMusicSource();
            SetUp();
        }
        else
        {
            Destroy(gameObject);
        }
    }

    private void Start()
    {
        GameManager.Instance.StateEnter.AddListener(OnStateEnter);
        PlayMusic(MUSIC.Menu);
    }

    private void Update()
    {
        musicSource.volume = musicVolume;
    }

    private void SetUp()
    {
        sfxClips = new Dictionary<SFX, AudioClip>
        {
            { SFX.Collectible1, (AudioClip)Resources.Load("Firefly1", typeof(AudioClip)) },
            { SFX.Collectible2, (AudioClip)Resources.Load("Firefly2", typeof(AudioClip)) },
            { SFX.Damage1, (AudioClip)Resources.Load("Damage1", typeof(AudioClip)) },
            { SFX.Damage2, (AudioClip)Resources.Load("Damage2", typeof(AudioClip)) },
            { SFX.Death, (AudioClip)Resources.Load("Death", typeof(AudioClip)) },
            { SFX.LunarHawk, (AudioClip)Resources.Load("LunarHawk", typeof(AudioClip)) },
            { SFX.MenuSelect, (AudioClip)Resources.Load("MenuSelect", typeof(AudioClip)) }
        };

        musicClips = new Dictionary<MUSIC, AudioClip>
        {
            { MUSIC.Menu, (AudioClip)Resources.Load("Menu", typeof(AudioClip)) },
            { MUSIC.GameIntro, (AudioClip)Resources.Load("Intro", typeof(AudioClip)) },
            { MUSIC.MainLoop, (AudioClip)Resources.Load("MainMusic", typeof(AudioClip)) }
        };
    }

    private void CreateMusicSource()
    {
        GameObject musicChild = new GameObject("Music");
        musicChild.transform.parent = transform;

        musicSource = musicChild.AddComponent<AudioSource>();
        musicSource.loop = true;
        musicSource.volume = musicVolume;
        musicSource.playOnAwake = false;
    }

    private void OnStateEnter(GameState state)
    {
        if (state.name == "StartState" || state.name == "TitleState" || state.name == "PauseState")
        {
            if(GameManager.Instance.previousState.name == "PauseState" && GameManager.Instance.currentState.name == "TitleState")
            {
                hasPlayedIntro = false;
            }
            if (musicSource.isPlaying)
            {
                currentMusicTime = musicSource.time;
            }

            PlayMusic(MUSIC.Menu, true);
        }
        else if (state.name == "PlayingState")
        {
            if (!hasPlayedIntro)
            {
                PlayMusic(MUSIC.GameIntro, false, 0f, () =>
                {
                    PlayMusic(MUSIC.MainLoop, true);
                });
                hasPlayedIntro = true;
            }
            else
            {
                PlayMusic(MUSIC.MainLoop, true, currentMusicTime);
            }
        }
        else if (state.name == "EndState")
        {
            currentMusicTime = 0f; 
            hasPlayedIntro = false;
            PlayMusic(MUSIC.Menu);
        }
    }

    public void PlayCollectible()
    {
        int randomChoice = Random.Range(0, 2);

        if (randomChoice == 0)
        {
            PlaySFX(SFX.Collectible1);
        }
        else
        {
            PlaySFX(SFX.Collectible2);
        }
    }

    public void PlayDamage()
    {
        int randomChoice = Random.Range(0, 2);

        if (randomChoice == 0)
        {
            PlaySFX(SFX.Damage1);
        }
        else
        {
            PlaySFX(SFX.Damage2);
        }
    }

    public void PlayDeath()
    {
        PlaySFX(SFX.Death);
    }

    public void PlaySFX(SFX name)
    {
        if (sfxClips.TryGetValue(name, out AudioClip clip))
        {
            source.PlayOneShot(clip, sfxVolume);
        }
    }

    public void PlayLunarHawk()
    {
        PlaySFX(SFX.LunarHawk);
    }

    public void PlayMenuSelect()
    {
        PlaySFX(SFX.MenuSelect);
    }

    public void PlayMusic(MUSIC music, bool loop = true, float startTime = 0f, UnityEngine.Events.UnityAction onComplete = null)
    {
        if (musicClips.TryGetValue(music, out AudioClip clip))
        {
            if (musicSource.clip != clip || !musicSource.isPlaying)
            {
                musicSource.clip = clip;
                musicSource.time = startTime;
                musicSource.loop = loop;
                musicSource.Play();

                if (!loop && onComplete != null)
                {
                    StartCoroutine(WaitForClipToEnd(clip.length - startTime, onComplete));
                }
            }
        }
        else
        {
            Debug.LogWarning($"Music clip {music} not found in dictionary.");
        }
    }

    private IEnumerator WaitForClipToEnd(float duration, UnityEngine.Events.UnityAction callback)
    {
        yield return new WaitForSeconds(duration);
        callback?.Invoke();
    }
}