Portfolio Felix Huiskamp – Game Developer

Auteur: felix.huiskamp

  • Game Jam – Young and Old

    Game Jam – Young and Old

    Schooljaar 3 periode 1 

    In periode 1 van schooljaar 2025 – 2026 hadden we een game jam voor 1 week. De project was een Game gemaakt met Unity C#. Ik had toen besloten om de UI te gaan programmeren. Ik had dus toen de Main Menu, Settings en Win screen gemaakt. 

    Main Menu scherm van het spel met interactieve knoppen. Druk op Play om het spel te beginnen. Als je settings wilt aanpassen druk je dan op Settings. Druk op Quit als je het spel wilt verlaten.

    Pause Menu met Resume, Main Menu, en Quit knop. Resume zorgt ervoor dat ik het spel kan hervatten door middel van op de knop te drukken. Ik kan op de Main Menu knop drukken om terug naar het Main Menu te gaan. Als ik het spel wil verlaten druk ik dan op Quit.

    Copy Code
      
    public void PlayGame()
    {
        // Load the main game scene
        SceneManager.LoadScene(
        SceneManager.GetActiveScene()
        .buildIndex + 1);
    }

    public void OpenSettings()
    {
        mainMenuPanel.SetActive(false);
        settingsPanel.SetActive(true);
    }

    public void BackToMenu()
    {
        mainMenuPanel.SetActive(true);
        settingsPanel.SetActive(false);
    }

    Dit script is onderdeel van het Main Menu van de 2D-game. Het script zorgt voor de navigatie binnen het hoofdmenu. Met de PlayGame()-functie kan de speler het spel starten, waarbij de volgende scene automatisch wordt geladen. Daarnaast kunnen spelers via OpenSettings() het instellingenmenu openen en met BackToMenu()terugkeren naar het hoofdmenu. Hierdoor kan de speler eenvoudig tussen de verschillende menu’s navigeren voordat het spel begint.

  • Ultrakill-Slideshow

    Ultrakill-Slideshow

    In periode 2 van schooljaar 2024-2025 kregen we de opdracht om een bestaande game na te maken. Hiervoor konden we kiezen uit verschillende games die in een slideshow werden gepresentterd. Ik heb gekozen voor ULTRAKILL. Voor dit project werkten we samen met de Game-Artists in een team van zes personene, bestaande uit drie Game-Developers en drie Game-Artists. We hebben ongeveer tien weken aan het project gewerkt.

    Tijdens dit project heb ik mij als Game Developer onder andere beziggehouden met het programmeren van verschillende gameplay-systemen. Zo heb ik een health-systeem ontwikkeled waarmee de gezondheid van de speler wordt bijgehouden en weergegeven via een healthbar in de UI. Daarnaast heb ik een movement-systeem met een dash gemaakt, waarmee de speler snel kan bewegen en een beperkt aantal dashes kan gebruiken.

    Copy Code
    public class PlayerHealth : MonoBehaviour
{

    [Header("Health Settings")]
    [SerializeField] private float maxHealth = 100f;
    private float currentHealth;

    [Header("UI")]
    public Slider healthBar;
    public GameObject deathScreen; 
    void Start()
    {
        //Geeft de speler max health als je begint met het spel.

        currentHealth = maxHealth;

        if (healthBar != null)
        {     
            healthBar.maxValue = maxHealth;
            healthBar.value = currentHealth;
        }

        if (deathScreen != null) 
        { 
            deathScreen.SetActive(false);
        }
    }
}

    Health script

    De PlayerHealth is een script dat verantwoordelijk is voor het bijhouden van de gezondheid van de speler binnen de shooting game. Bij het starten van het spel wordt de gezondheid ingesteld op de maximale waarde van 100 HP. Daarnaast wordt de healthbar in de gebruikersinterface automatisch ingesteld op de juiste maximale en huidige gezondheid. Ook wordt het death screen bij het opstarten uitgeschakeld, zodat dit pas zichtbaar wordt wanneer de spelen sterft. Hierdoor vormt het script de basis voor het health- en death-systeem van de game.

    Copy Code
    public class PlayerDash : MonoBehaviour
{
    void HandleMovement()
    {
        float moveX = Input.GetAxis("Horizontal");
        float moveZ = Input.GetAxis("Vertical");

        moveDirection = (cameraTransform.forward * moveZ + cameraTransform.right  * moveX).normalized;
        controller.Move(moveDirection * moveSpeed * Time.deltaTime);
    }

    //Zorgt ervoor dat de player max 3 keer kan dashen met Left shift.

    void HandleDashInput()
    {
        if (Input.GetKeyDown(KeyCode.LeftShift) && currentDashes > 0)
        {
            StartDash(); 
        }
    }

}

    Dash script

    Het HandleMovement- en HandleDashInput-gedeelte zijn onderdeel van het movement-systeem van de speler. Met HandleMovement wordt de speler bestuurd op basis van horizontale en verticale input. De bewegingsrichting wordt hierbij aangepast aan de positie en richting van de camera, zodat de speler beweegt in de richting waarin de camera kijkt. Daarnaast bevat de script een dash-functionaliteit waarmee de speler een snelle beweging kan uitvoeren door op Left Shift te drukken. De Speler kan maximaal drie keer achter elkaar dashen, afhankelijk van het aantal keer beschikbare dashes.

  • Game Jam

    Game Jam

    Game Jam van periode 1 Jaar 3

    Tijdens de eerste week van periode 1 van het schooljaar 2025-2026 kregen we drie dagen de tijd om deel te nemen aan een Game Jam. Hierbij was het bedoeling om binnen een korte tijd een creatief gameconcept te bedenken en uit te werken. Ik heb ervoor gekozen om een Commands-systeem te ontwikkelen waarmee objecten in de game via tekst commando’s aangestuurd kunnen worden.

    Naast het Commands-systeem heb ik gewerkt aan een Enemy Patrol-systeem. Hiermee kunnen vijanden zelfstandig door de omgeving navigeren via vooraf ingestelde waypoints. Hiervoor heb ik onder andere gebruikgemaakt van C#, Unity en de NavMeshAgent-component.

    Copy Code
    public class CommandExecutor : MonoBehaviour
{
    /// <summary>
    /// Voert een command uit in de vorm van "ObjectName MethodName [param1] [param2] ..."
    /// </summary>
    public void ExecuteCommand(string command)
    {
        if (string.IsNullOrWhiteSpace(command))
        {
            Debug.LogWarning("[CommandExecutor] Leeg commando ontvangen.");
            return;
        }
}

    Commands Script

    De CommandExecutor is een script dat verantwoordelijk is voor het verwerken en uitvoeren van commando’s binnen Unity. Het script controleert eerst of er een geldig commando is ingevoerd. Wanneer het commando leeg is, wordt er een waarschuwing weergegeven en stopt de uitvoering. Dit vormt de basis voor een systeem waarmee objecten en hun bijbehorende methodes via tekstcommando’s aangestuurd kunnen worden.

    Copy Code
    public class EnemyPatrol : MonoBehaviour
{
    public Transform[] waypoints;
    public float waitTime = 2f;

    private int currentWaypointIndex = 0;
    private NavMeshAgent agent;
    private float waitTimer;
    void Start()
    {
        agent = GetComponent<NavMeshAgent>();

        if (waypoints.Length > 0)
        {
            agent.SetDestination(waypoints[currentWaypointIndex].position);
        }
    }
}

    Enemy AI Script

    De EnemyPatrol is een script dat ervoor zorgt dat een vijand zelfstandig tussen verschillende vooraf ingestelde waypoints beweegt. Hiervoor wordt gebruikgemaakt van een NavMeshAgent, waarmee de vijand automatisch zijn weg kan vinden binnen de omgeving. Bij het starten van het script wordt gecontroleerd of er waypoints zijn ingesteld. Als dit het geval is, beweegt de vijand naar het eerste waypoint. Daarnaast zijn variabelen toegevoegd om onder andere de wachttijd tussen bewegingen te bepalen.

  • Tower – Defense

    Tower – Defense

    Project van periode 1 schooljaar 2

    In periode 1 van schooljaar 2024 – 2025 kregen we een Tower defense project en kon je kiezen welke thema je de game mee ging maken. Ik had toen Sci-fi gekozen en ging ik in mijn eentje aan het werk. Ik deed er ongeveer 10 weken over om het spel te maken.

    Copy Code
    Collider2D[] targetsInRange = Physics2D.OverlapCircleAll(
     transform.position, range, alienLayer);

        foreach (Collider2D target in targetsInRange)
        {
            
            if (target.CompareTag("Alien"))
            {
                AimAtTarget(target.transform);

                if (fireCountdown <= 0f)
                {
                    Shoot();
                    fireCountdown = 1f / fireRate; 
                }

                fireCountdown -= Time.deltaTime;
                break; 
            }

        }
}