Concept

Survive the creation of the universe as the first
hydrogen atom called Hydro.
Battle the endless stream of Void Creatures with
the one goal of making it to the creation.

Project Details

Plattform:
Genre:
Engine:
Development time:
Restrictions:

PC
Unity
Rouge-like
3 weeks
Xbox Adaptive Controller

Roles and Responsibility

Technical Gameplay Design

Rapid Prototyping,
Script optimizing,
Ideating features,
Implementing features

First Day Prototype

I made a quick game prototype to get everyone on the same page

Game Prototype

_{I prototyped the full game on the first day including movement,

simple enemies and two abilities to get a feel if the game was fun.

This helped the team understand the vision of the game and helped me

start prototyping other things without having to wait for programmers.}

Technical Gameplay Design

Worked on all the abilites for the game

Workflow

The workflow I used during this project.
It helped me make more abilites during a shorter time period.

Abilities

_{We had a goal to get 5 working abilities in the game before the deadline.

The goal of the abilities was to make the player feel powerful

and for them to compliment the constant movement.

I designed and scripted them.}

Takeaways

What I learned, liked and disliked

Collaborating with programmers to optimize and make my code better was super fun!
This was the first time I utilized my quick prototyping which helped the team and made me find what I like!

Thank you for reading!

            
            AreaDamage Script

            private void Start()
                {
                    //_renderer = areaObject.GetComponent();
                    //originalColor = _renderer.material.color;
                    InvokeRepeating("DamageTick", 0.0f, timeBetweenAttacks);
                    areaObject.transform.localScale = new Vector3(1, 1, 1) * radius/3;
                    startRotation = areaObject.transform.rotation; 
                }
                private void Update()
                {
                    areaObject.transform.rotation = startRotation;
                }

                /*private void Update()
                {
                    // Constantly change color
                    timer += Time.deltaTime;
                    float lerpValue = (Mathf.Sin(timer / timeBetweenAttacks * Mathf.PI * 2) + 1) / 2; // Oscillates between 0 and 1
                    _renderer.material.color = Color.Lerp(originalColor, flashColor, lerpValue);

                    areaObject.transform.localScale = new Vector3(radius * 2, areaObject.transform.localScale.y, radius * 2);
                }*/

                private void DamageTick()
                {
                    Collider[] enemiesInRange = Physics.OverlapSphere(transform.position, radius, enemyMask);
                    foreach (Collider enemyCollider in enemiesInRange)
                    {
                        S_EnemyHealthController emc = enemyCollider.GetComponent
    ();
    if (emc != null)
    {
    emc.TakeDamage(damage);
    }
    }
    _____________________________________________________________________________________________________________________

            DamgeTrail Script

            private void Start()
            {
            isOnPlayer = gameObject.transform.root.tag == "Player";
            maxTrailLength = Mathf.FloorToInt(trailLengthTime / spawnInterval);
            trailBulletQueue = new Queue
                ();
                trailRenderer = GetComponent
                    ();
                    trailWdith = trailRenderer.startWidth;

                    trailRenderer.time = trailLengthTime;
                    }

                    private void Update()
                    {
                    if (!isOnPlayer)
                    {
                    transform.localPosition = new Vector3(0f, 0f, 3 + math.sin(Time.time * 3) * 3f);
                    }

                    spawnTimer += Time.deltaTime;
                    damageTimer += Time.deltaTime;
                    if (spawnTimer >= spawnInterval)
                    {
                    SpawntrailBullet();
                    spawnTimer = 0;
                    }

                    if (damageTimer >= damageTickInterval)
                    {
                    DamageEnemies();
                    damageTimer = 0;
                    }
                    }

                    private void SpawntrailBullet()
                    {
                    Vector3 spawnPosition = transform.position;
                    GameObject newtrailBullet;
                    if (trailBulletQueue.Count < maxTrailLength)
                    {
                    newtrailBullet = Instantiate(trailColliderPrefab, spawnPosition, Quaternion.identity);
                    newtrailBullet.transform.localScale = Vector3.one * trailWdith;
                    }
                    else
                    {
                    newtrailBullet = trailBulletQueue.Dequeue();
                    newtrailBullet.transform.position = spawnPosition;
                    }

                    trailBulletQueue.Enqueue(newtrailBullet);
                    }

                    private void DamageEnemies()
                    {
                    StartCoroutine(FlashTrail());
                    foreach (GameObject trailBullet in trailBulletQueue)
                    {
                    Collider[] overlappingColliders = Physics.OverlapSphere(trailBullet.transform.position, trailWdith / 2);
                    foreach (Collider col in overlappingColliders)
                    {
                    S_EnemyHealthController enemy = col.gameObject.GetComponent
                    ();
                    if (enemy != null)
                    {
                    enemy.TakeDamage(damageAmount);
                    }
                    }
                    }
                    }


                    private IEnumerator FlashTrail()
                    {
                    Color originalColor = trailRenderer.startColor;
                    trailRenderer.startColor = flashColor;
                    trailRenderer.endColor = flashColor;

                    yield return new WaitForSeconds(flashDuration);

                    trailRenderer.endColor = originalColor;
                    trailRenderer.startColor = originalColor;
                    }
    _______________________________________________________________________________________________________________

                        KillRadomOnScreenScript

                        private void Awake()
                        {
                        CreateBoltPool(initialBoltPoolSize);
                        }

                        private void OnEnable()
                        {
                        Kill();
                        elapsedTime = 0;
                        }

                        private void OnDisable()
                        {
                        foreach (GameObject bolt in boltPool)
                        {
                        if (bolt != null)
                        bolt.SetActive(false);
                        }
                        }
                        void Update()
                        {
                        elapsedTime += Time.deltaTime;

                        if (elapsedTime >= timeBetweenKills)
                        {
                        elapsedTime = 0f;
                        Kill();
                        }
                        }

                        private void CreateBoltPool(int size)
                        {
                        for (int i = 0; i < size; i++)
                        {
                        GameObject bolt = Instantiate(boltPrefab);
                        bolt.SetActive(false);
                        boltPool.Add(bolt);
                        }
                        }

                        private GameObject GetBoltFromPool()
                        {
                        foreach (GameObject bolt in boltPool)
                        {
                        if (!bolt.activeInHierarchy)
                        {
                        return bolt;
                        }
                        }

                        GameObject newBolt = Instantiate(boltPrefab);
                        boltPool.Add(newBolt);
                        return newBolt;
                        }

                        private void Kill()
                        {
                        killableEnemies.Clear();
                        foreach (Collider enemy in Physics.OverlapSphere(transform.position, killRange, enemyLayer))
                        {
                        // Debug.Log(enemy.name);
                        killableEnemies.Add(enemy.gameObject);
                        }

                        if (killableEnemies.Count <= 0)
                        return;
                        for (int i = 0; i < numKills; i++)
                        {
                        KillRandomEnemy();
                        }
                        AudioManager.Instance.PlaySound3D("Cern-TainDeath", transform.position);
                        }

                        private void KillRandomEnemy()
                        {
                        GameObject tempEnemy = killableEnemies[Random.Range(0, killableEnemies.Count)];
                        S_EnemyHealthController tempHealthController = tempEnemy.GetComponent
                            ();
                            tempHealthController.TakeDamage(damage);
                            CreateBolt(tempEnemy.transform);
                            }

                            private void CreateBolt(Transform enemyTransform)
                            {
                            GameObject bolt = GetBoltFromPool();
                            bolt.transform.position = enemyTransform.position;
                            bolt.transform.rotation = Quaternion.identity;
                            bolt.SetActive(true);
                            StartCoroutine(DisableBoltAfterTime(bolt, boltLifetime));
                            }

                            private IEnumerator DisableBoltAfterTime(GameObject bolt, float time)
                            {
                            yield return new WaitForSeconds(time);
                            bolt.SetActive(false);
                            }