Ghost'n Games

Engine

Unity
Language

C#
Duration

48 hours
Team Size

3
Role

Programmer

Responsibilities:

Minigames

Coded and implemented the pacman minigame
Coded and implemented the GTAV minigame

Debugger

Helped other teammate when issues arose

Other

Coded and implemented the GameController/PlayerController

Code:

PacMan MiniGame

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

public class PacManManager : MonoBehaviour
{
    public int AiAlive = 4;
    public static PacManManager instance { get; private set; }

    public List<AI> Enemies;
    [SerializeField] private float delayedStartTimer;
    private bool enemiesStart;
    public bool gameStart;
    public GameObject winScreen;
    private bool queued;
    public GameObject cherryCollectable;
    public GameObject bar;

    public bool jumpscare;


    private void Awake()
    {
        instance = this;
    }

    private void Start()
    {
        PlayerBehaviour.instance.enabled = false;
    }

    private void Update()
    {
        if (gameStart)
        {
            if (Enemies.Count == 0 && !queued)
            {
                winScreen.SetActive(true);
                SceneLoader.instance.NextScene(5);
                PlayerPrefs.SetInt("MiniGamesWon", PlayerPrefs.GetInt("MiniGamesWon", 0) + 1);
                queued = true;
            }

            if (delayedStartTimer > 0)
            {
                delayedStartTimer -= Time.deltaTime;
            }
            else if (!enemiesStart)
            {
                enemiesStart = true;
                bar.SetActive(false);
                StartCoroutine("BarRise");
                for (int i = 0; i < Enemies.Count; i++)
                {
                    Enemies[i].movement = AI.movementState.chasing;
                }
            }
        }
    }

    IEnumerator BarRise()
    {
        yield return new WaitForSeconds(5f);
        bar.SetActive(true);
    }

    public void StartGame()
    {
        gameStart = true;
        PlayerBehaviour.instance.enabled = true;
        StartCoroutine(spawnCherry());
    }

    public void DisableAI()
    {
        for(int i =0; i < Enemies.Count;i++)
        {
            Enemies[i].agent.enabled = false;
        }
    }

    IEnumerator spawnCherry()
    {
        yield return new WaitForSeconds(10f);
        Instantiate(cherryCollectable, new Vector3(0f, 3.2f, 0f), Quaternion.identity);
    }
}

-------------------------------------------------------------------------------------------------
=================================================================================================
                                        //AI CODE BELOW//
                                    //VERY BASIC DUE TO TIME//
=================================================================================================
-------------------------------------------------------------------------------------------------

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

public class AI : MonoBehaviour
{
    public NavMeshAgent agent;
    public Transform target;
    [SerializeField] private Sprite deathSprite;
    [SerializeField] private SpriteRenderer sr;
    [SerializeField] private Animator anim;
    private bool ded;
    [SerializeField] private PlayerBehaviour player;
    [SerializeField] private Rigidbody2D rb;
    [SerializeField] private Collider2D circle;
    [SerializeField] private AudioSource audio;
    [SerializeField] private AudioClip clip;

    public enum movementState
    {
        idle,
        chasing,
        scared
    }

    public movementState movement = movementState.idle;

    private void Awake()
    {
        agent.updateRotation = false;
        agent.updateUpAxis = false;
        StartCoroutine(PathFinding());
    }

    private void Update()
    {
        if (!ded && movement != movementState.idle)
        {
            if (player.powerup || player.immune)
            {
                anim.SetBool("scared", true);
                movement = movementState.scared;
            }
            else if (!player.powerup)
            {
                anim.SetBool("scared", false);
                movement = movementState.chasing;
            }
        }
    }

    IEnumerator PathFinding()
    {
        while (true)
        {
            if(ded)
                yield break;
            if (!ded && movement != movementState.idle && agent.enabled)
            {
                if (movement == movementState.chasing)
                {
                    agent.SetDestination(target.position);
                }
                else if (movement == movementState.scared)
                {
                    agent.SetDestination(transform.position - player.gameObject.transform.position);
                }
                yield return null;
            }
            yield return new WaitForEndOfFrame();
        }
    }

    IEnumerator deadSequence()
    {
        yield return new WaitForEndOfFrame();
        agent.enabled = false;
        yield return new WaitForEndOfFrame();
        audio.Play();
        rb.constraints = RigidbodyConstraints2D.None;
        circle.enabled = false;
        rb.AddForce(Vector3.up * 400);
        Destroy(gameObject, 4);
        PacManManager.instance.Enemies.Remove(this);
        yield return null;
    }

    private void OnTriggerEnter2D(Collider2D collision)
    {
        if (collision.gameObject.CompareTag("Player"))
        {
            if (PlayerBehaviour.instance.powerup)
            {
                sr.sprite = deathSprite;
                ded = true;
                StartCoroutine(deadSequence());
            }
            else
            {
                if (!PacManManager.instance.jumpscare)
                {
                    PacManManager.instance.jumpscare = true;
                    StartCoroutine(JumpScare());
                    PlayerBehaviour.instance.inputEnabled = false;
                    PlayerBehaviour.instance.AddLivesToSelf(-1);
                }
            }
        }
    }

    IEnumerator JumpScare()
    {
        audio.clip = clip;
        sr.sortingOrder = 10;
        agent.enabled = false;
        transform.position = new Vector3(0,-2,0);
        float time = 0;
        audio.Play();
        while (time < 1)
        {
            transform.localScale = Vector3.Lerp(transform.localScale, new Vector3(18, 18, 18), .5f);
            time += Time.deltaTime;
            yield return new WaitForSeconds(.05f);
        }
        yield return null;

        yield return new WaitForSeconds(5);
        SceneLoader.instance.ReturnToMainMenu();
    }
}

Player Behaviour

                            
                            
                                
                            

    using System.Collections;
    using System.Collections.Generic;
    using TMPro;
    using UnityEngine;
    using UnityEngine.UI;

    public class PlayerBehaviour : MonoBehaviour
    {
        public float speed;
        public int score = 0;
        public TMP_Text scoreTxt;
        [SerializeField] private int playerLives = 3;

        public bool inputEnabled = true;

        public bool immune;
        [SerializeField] private int immunityTime;
        private float immunityTimer;

        public bool powerup;
        [SerializeField] private float powerUpTotalTime;
        private float powerupTimer;
        public Sprite liveLost;
        public Sprite liveGain;
        public List<GameObject> livesImgs;
        private int nextLiveInd = 2;

        public static PlayerBehaviour instance { get; private set; }

        private Animator anim;

        private void Awake()
        {
            instance = this;
            playerLives = PlayerPrefs.GetInt("PlayerLives", playerLives);
            score = PlayerPrefs.GetInt("Score", 0);
            scoreTxt.text = ": " + score;
            for(int i =0; i < livesImgs.Count; i++)
            {
                if(i >= playerLives)
                {
                    livesImgs[i].GetComponent<Image>().sprite = liveLost;
                }
            }
            anim = gameObject.GetComponent<Animator>();
        }

        public void SetPlayerLives(int value)
        {
            if (immunityTimer <= 0)
            {
                if (value < playerLives)
                {
                    immunityTimer = immunityTime;
                }
                playerLives = value;
                PlayerPrefs.SetInt("PlayerLives", playerLives);
            }
            else
            {
                Debug.Log("Player Immune");
            }
        }

        public void AddLivesToSelf(int value)
        {
            if (immunityTimer <= 0)
            {
                if (playerLives + value < playerLives)
                {
                    immune = true;
                    immunityTimer = immunityTime;
                }
                playerLives += value;
                if (value > 0)
                {
                    livesImgs[nextLiveInd].GetComponent<Image>().sprite = liveGain;
                    nextLiveInd++;
                }
                else
                {
                    livesImgs[nextLiveInd].GetComponent<Image>().sprite = liveLost;
                    nextLiveInd--;
                    if (playerLives <= 0)
                        SceneLoader.instance.GameOverScene();
                    else
                        SceneLoader.instance.NextScene(3);
                }

                //lives.text = "Lives: " + playerLives.ToString();
                PlayerPrefs.SetInt("PlayerLives", playerLives);
            }
            else
            {
                Debug.Log("Player Immune");
            }
        }

        public void AddScoreToSelf(int value)
        {
            score += value;
            scoreTxt.text = ": " + score.ToString();
            PlayerPrefs.SetInt("Score", score);
        }

        public int GetPlayerLives()
        { return playerLives; }

        public void PowerUp()
        {
            Debug.Log("POWERUP");
            powerupTimer = powerUpTotalTime;
            powerup = true;
            anim.SetBool("Cross", true);
        }

        void Update()
        {
            if(immunityTimer > 0)
            {
                immunityTimer -= Time.deltaTime;
            }
            else if(immunityTimer <= 0 && immune)
            {
                immune = false;
            }

            if(powerupTimer > 0)
            {
                powerupTimer -= Time.deltaTime;
            }
            else if(powerupTimer <= 0 && powerup)
            {
                powerup = false;
                anim.SetBool("Cross", false);
            }

            if (inputEnabled)
            {
                if (Input.GetKey(KeyCode.LeftArrow) || Input.GetKey(KeyCode.A))
                {
                    transform.Translate(Vector2.left * speed * Time.deltaTime);
                    anim.SetInteger("Direction", 0);
                }
                if (Input.GetKey(KeyCode.RightArrow) || Input.GetKey(KeyCode.D))
                {
                    transform.Translate(Vector2.right * speed * Time.deltaTime);
                    anim.SetInteger("Direction", 2);
                }
                if (Input.GetKey(KeyCode.UpArrow) || Input.GetKey(KeyCode.W))
                {
                    transform.Translate(Vector2.up * speed * Time.deltaTime);
                    anim.SetInteger("Direction", 1);
                }
                if (Input.GetKey(KeyCode.DownArrow) || Input.GetKey(KeyCode.S))
                {
                    transform.Translate(Vector2.down * speed * Time.deltaTime);
                    anim.SetInteger("Direction", 3);
                }
            }
        }
    }

Download on itch.io

Ghost'n Games

Engine

Language

Duration

Team Size

Role

Responsibilities:

Minigames

Debugger

Other

Code:

PacMan MiniGame

Player Behaviour