Gameplay Programmer // Unreal, Unity, Shaders

Hello! I am Andrej Burovski

Now loading Game programming, interactive systems, and real-time visuals built with a developer mindset and a player-facing eye for feel.

View Projects Resume

What I do

Design + Development

A passionate gameplay and tools programmer who loves to design and develop game-focused applications.

Languages

C++, C#, Python, MySql HTML/CSS

Engines & frameworks

Unreal Engine 4, Unity, GameMaker, Pygame, WinForms, Git & Github, Perforce, HacknPlan

About Me Contact Me

Who I am

Gameplay programmer / technical generalist

My passion lies in game development. I am an independent developer who enjoys learning, taking on difficult problems, and designing gameplay systems.

Working across different projects keeps me growing, and I especially enjoy building interactive experiences that can connect with a wide range of players.

Outside client work, I am usually developing a personal project, joining a game jam, powerlifting, or exploring the highlands near home. I am always interested in thoughtful new projects, so send me an email if you would like to work together.

Project Archive

My work

A selection of gameplay systems, shader studies, prototypes, and game jam projects.

01 / 04

CRT Display and Font-Corruption System

The CRT system is a modular Unreal Engine UI-effects framework that recreates the visual behavior of analog displays. It combines CRT material processing - such as scanlines, glow, flicker, distortion, chromatic separation, and signal instability - with a font-corruption layer capable of altering displayed characters dynamically. The system is implemented in C++ for reusable runtime control while exposing its primary parameters and functions to Blueprint, allowing artists to build effects without modifying shader or gameplay code.

A central CRT controller provides a consistent runtime API for changing effect intensity, corruption state, and material parameters. These properties can be driven from Blueprint events, animations, sequencers, or gameplay systems, enabling effects to react to damage, power loss, interference, proximity, narrative events, or player interaction.

Dolly zoom / Vertigo effect

A dolly zoom is an in-camera effect that appears to undermine normal visual perception. The effect is achieved by zooming a zoom lens to adjust the angle of view while the camera dollies toward or away from the subject in such a way as to keep the subject the same size in the frame throughout.

ColorShooter

This is a small First-person C++ project. The goal of this game is that every time we shoot an object it shrinks and disappears under a certain threshold hits, when we hit the cubes we get feedback by changing its color. You can check the main functionality written in C++ below

Source Panel AFPSProjectile::OnHit

void AFPSProjectile::OnHit(
    UPrimitiveComponent* HitComp, AActor* OtherActor, UPrimitiveComponent* OtherComp, FVector NormalImpulse, const FHitResult& Hit){
    // Only add impulse and destroy projectile if we hit a physics
    if ((OtherActor != NULL) && (OtherActor != this) && (OtherComp != NULL) && OtherComp->IsSimulatingPhysics()){
        OtherComp->AddImpulseAtLocation(GetVelocity() * 100.0f, GetActorLocation());

        FVector _Scale = OtherComp->GetComponentScale();
        // Make it smaller
        _Scale = _Scale * 0.8f;

        if (_Scale.GetMin() < 0.5f){
            // We cant to destry the whole Actor not just the component
            OtherActor->Destroy();}
        else{
            OtherComp->SetWorldScale3D(_Scale);}

        UMaterialInstanceDynamic* _MatInst = OtherComp->CreateAndSetMaterialInstanceDynamic(0);
        if(_MatInst){
            // Change the RGB color, stored in a vector
            _MatInst->SetVectorParameterValue("Color", FLinearColor::MakeRandomColor());}}}

Interacting systems

Interacting system components that can be attached to any actor, apply physics forces to components that are detected through tracing.

01 / 02

Shader HLSL 01

This shader builds a procedural sci-fi light pattern designed to make a surface feel active, digital, and slightly unpredictable, like a futuristic panel, reactor surface, or diagnostic display, without relying on texture inputs.

It uses HLSL-driven randomness over a simple grid so each cell gets its own timing, motion, and intensity. That variation keeps the animation from feeling mechanical while still preserving a clean, engineered structure.

A small set of exposed parameters controls density, speed, brightness, sharpness, and how many cells remain inactive, making the effect easy to art-direct. The final result sits between interface design and ambient motion: ordered, readable, and still alive.

Shader HLSL 02

This shader creates a procedural violet wave-and-ripple floor for a magical or cyber sci-fi surface. It uses HLSL to generate subtle flowing waves and random rain-like ripples without texture inputs.

The wave layer gives the floor constant soft motion, while the ripple layer creates expanding rings that appear, spread, echo, and fade like drops hitting water. Each ripple has randomized size, thickness, brightness, speed, and position, with occasional larger ripples for more natural variation.

The material uses world-space floor projection, so the effect stays stable on large floors and platforms. Separate parameters control wave color, ripple color, wave movement, ripple density, ripple size range, ripple speed, and emissive pulse strength.

The final result is a dark violet animated surface with subtle background motion, glowing varied ripples, rare larger impacts, and a soft breathing glow. It feels like a mix between magical water, cyber energy, and an abstract sci-fi floor.

Shaders

CubicLerp between 4 points

Math Source QuadraticLerp / CubicLerp

private Vector3 QuadraticLerp(Vector3 a, Vector3 b, Vector3 c, float t){
Vector3 ab = Vector3.Lerp(a, b, t);
Vector3 bc = Vector3.Lerp(b, c, t);
return Vector3.Lerp(ab, bc, interpolateAmount);}

private Vector3 CubicLerp(Vector3 a, Vector3 b, Vector3 c, Vector3 d, float t){
Vector3 ab_bc = QuadraticLerp(a, b, c, t);
Vector3 bc_cd = QuadraticLerp(b, c, d, t);
return Vector3.Lerp(ab_bc, bc_cd, interpolateAmount);}

2D RPG adventure

Currently building a 2D RPG-style game, still havent defined most of the functionalities of this game.

Ballz

A simple Ballz game where every wave you get to lunch one more ball. Every wave is more difficult, try to survive as much time as you can.

Bob in Colorland

I was solo developing this game for the purpose of the gamejam+ competition. The game is about a painter who is collecting colors to paint his way to glory. Each collected color gives you a special ability, for example, blue once gives you access to spawning platforms.

Defector

Defector 2D Platformer was made in Unreal Engine with a team of three people. Me as programmer, game designer, and artist. My Programming Responsibilities were to implement the UI and its functionalities, design all the moving scaling and rotating platforms, and implement the system for health.

The Last Kompir

The Last Kompir is a hack and slash survivor game mede in Unreal Engine. You are fighting with waves of vegetable zombies to survive the adventure. I scripted the platforms for dashing and launching the player into the air and also the logic for the waves of enemies.

Shadow's Rune

I'm really proud of this project since the whole level was designed and programmed by me in Unreal Engine. My responsibility was to design the whole level to be scary and implement mechanics for picking all the letters in the level. This game is based on Horror-Puzzle experience about a single father with daughter whom had unexplained twist of events as the daughter dies of unnatural reasons. The father falls in huge depression to find his way out of the protagonist hypnotic possession, as he is being awaken in an alter reality of a dreams including himself being tortured on their happy moments they used to had before.

Snake

Basic version off snake made in python and pygame.

Turtle race

This is a small project where The user picks how many turtles they want to race, and the program will race that many turtles by randomly moving them across the screen.

Pathfinding visualizer

Pathfinding Visualization

Simple path finding visualizer tool to visualize the a star pathfinding algorithm as it runs. This astar pathfinding algorithm is an informed search algorithm which means it is much more efficient that your standard algorithms like breadth first search or depth first search. You have to specify the start and end point, then draw all the obstacles on the map.

Battleships

Battleship is a war-themed board game for two players in which the opponents try to guess the location of the other's various ships.The goal of the game is to sink all of the opponent's ships by correctly guessing their location on the grid.