Age Of Space

Download here

During my intership semester I worked on Age of Space developing gameplay functionaliy and tools to ease further tasks for the other team members. I've worked on multiple aspects of the game. Originally I focused on the SteamAPI and Photon for the networking aspects of the game. Later on I shifted focus to developing an IK solution for the turrets in the game, able to support any amount of joints in order to target the enemy. This allowed us to quickly develop weaponry for different factions, some working on a regular 2 joint swivel, similar to current real world technologies while others having multiple joins and acting more like a robotic arm.

I continued working on the Age of Space project, and later I developed the pathfinding as a 3D implementation of the A* algorithm and I based the movement on the Boids program, developed by Craig Reynolds.

I created an ecosystem logic, where entities would work based on their function, allowing quick implementation of new elements in a scene simulating an active "base". This allowed us to have mining ships leave space stations, mine and retrieve the resources, firing events in order to affect a future economy, as well as any other ships creating a traffic of sorts as well as giant carriers warping in, delivering cargo and warping out.

One of the tools I created is a dynamic cinematic system based on a Finite State Machine. It allows the quick addition of any behaviour and is designed to replicate popular camera actions seen in Battlestar Galactica, Star Wars or any other movies I like. It supports following a target, orbiting it, making specific movements, even following predetermined or dynamically created curves around a position.

• Download Here

Go Back

Asteroids

Download here

Tried my luck at participating in the GBJAM5 with my entry, Numerous small celestial bodies composed of rock and metal, aka Asteroids.Really the hardest part of making this was the shader, everything else is just simple scripting.

• Download Here

Go Back

At the strike of Midknight

Download here

The theme for this jam was "At the Strike of MidKnight" and we took that quite literally. It's a tower defense game where the player is a princess in her castle, minding her own business, when knights start showing off decided to "save" her. In the current version of the game she can place down different towers and walls however the idea was that creatures which in fairy tales would seem evil, especially to the knights, would be her friends and help her get the knights to leave her alone.

The game relies on a hexagonal grid and uses breadth-first search to find all of the shortest paths. I chose this instead of A* because I wanted all possible paths from the spawn point to the target, not just for one entity. The pathfinding gets recalculated every time obstacles are changed on the map by the player.

Oh and the flowers are procedurally generated.

Credits:
- Austeja Vaicyte | Lead Artist
- Edward Giurgiu | Artist
- Theodor F Purcaru | Programmer

• Download Here

Go Back

Autonomous Robot

During the first semester of the Computer Science Master at AAU, I chose to be part of a project covering autonomous robotic solutions. Our proposed solution aimed to make a robot with a minimalist hardware design. As such, the robot only had one ultrasonic sensor, alter changed to an IR sensor for more exact results. Instead of odometry via a wheel sensor or other similar solutions. The robot counts the loops on the arduino to measure the distance it has moved. In order to measure rotation, when the robot first starts, there is a initiation manouver, where it checks the distance to anything in front and then rotates until that same distance is detected again. This requires that the robot starts looking at something that is at a unique distance away from it. By doing this, we measure how many degrees it can do per loop, since when it finished, we've countent how many loops per 360 degrees. The robot then sends points of collisons through a bluetooth module to a hub application made in Unity.

The application takes each point and draws a map, it can connect to multiple robots and has the ability to send commands to the robot. The communication solution also has an acknowledgment functionality, where each message is acknowledged before forgotten, therefore, as the robot moves, it builds up a buffer of points, if the buffer reaches a set length, it stops moving, and the points are sent, until acknwoledged and then removed from the buffer.

Possible commands:
- new_phone_who_dis | the hub sends a request to each of the connected ports expecting back "IDENTIFIER|NAME". If the response comes back corectly, the hub adds the robot to a list.
- manual | the hub sends a request to the selected robot in the list, changing it's state to manual control, which can then be controlled by a remote UI on the hub, useful to test the movements of the robot and debug the sensor.
- start | wipes the memory of the robot of existing points and restarts the initiation function.
- ack | acknowledges the previous message, telling the received to stop sending the current message and continue in the buffer.
- pause | the robot stops moving and no longer sends messages with the points, but keeps them in the buffer.
- stop | the robot stops moving and no longer sends messages with the points as well as wiping them from memory.
- give_state | returns the current state of the robot to the hub app, containing the current length of the points buffer, the current objective (moving,rotating, etc) and the current loop counter.
In order to test the robot easily, I also built a simulation of it in Unity, the functionality was made the same as the arduino version of it. As such, anyone in the team could write their own implementation by creating an instance of the robot class which would allow them to make the robot move forward, rotate and use sensors.

Go Back

Chill, Murder & Sunshine

Download here

This is the first game I ever put a lot of focus on procedural generation. The idea was to create an RTS game where the player would start on an island and have enemies to handle on different islands with the final goal of wiping out all opposition. The procedural part comes in the form of creating the islands, placing environmental objects as well as enemies and locations of interest. The island is created by first running a perlin noise calculation. From it I create a mesh for each island. For spawning the objects, I could have used the same tehnique, but it would have seemed too inorganic. To solve that I used the Poisson Disc Sampling method, which allows picking spawning locations in areas without overlap. To finish, the sea is a shader I wrote in Cg.

The game is a classic RTS, in the style of warcraft. The player has a base of operations, can build units as well as other structures. However, the theme of the game is criminality. As such, resources are businesses, to which you send your units and they intimidate them to give money. We had a lot of fun designing the possible businesses as well as the units belonging to the mob boss.

The enemy is quite simple, acting more similarly to barbarians in CIV games. Basically they can keep spawning and take over businesses, but there's no real faction AI other than attacking units belonging to the player.

Credits:
- Austeja Vaicyte | Artist
- Theodor F Purcaru | Programmer

• Download Here

Go Back

Far Above

Download here

My role in the development of this game was that of Lead Developer. There was another programmer who had less experience than me, so I spread my time between actually developing features, creating tasks in trello and reviewing his work.
The game is a straightforward underwater level where the main goal is to get to the surface. Along the way, you'll encounter threats such as mines, smart bombs and underwater creatures. It also features a fun dialogue system between the two characters in the submarine, who react to different stimuli, such as the vessel having low health, low fuel, encountering certain enemies or simply piloting it badly.
It was designed with two players in mind, one controlling where the engine is directing the submarine while the other directing the turret, but that can also be done from one controller, each stick handling one of the tasks.

Responsabilities:
- Implement fuel/health of the vessel and display the info on the sub itself.
- Implement thrust and control over the engine.
- Implement the turret gameplay.
- Review the dialog functionality created by the other developer and advice/help wherever needed.
- Create behavior for mines, smart bombs and other enemies.
- Work together with the VFX person to create effects for the spotlight and explosions using Amplify Shader Editor.

• Download Here

Go Back

Far From Normal

Download here

The second time I ever participated in a gamejam, used the Unreal Engine though I had never opened it, my insanity is clear. The game is heavily reliant on it's narrative, taking the player through a wasteland and slowly giving him details of what happened, ending in the player having too much and deciding to do something about it.

Responsabilities:
- Creating the behavior for interacting with objects, showing them up close, for example, to read a newspaper.
- Creating the frost functionality, where the player has to hurry between camps, least he loose too much body heat and die.
- Make the end cinematic using the Sequencer tool in unreal.

• Download Here

Go Back

Far From Normal

Download here

The theme for this gamejam was "Spooky baby cultists". We decided to use the 4|44 rule. Where you spend the first four hours making a prototype of the whole game and if you're happy with what you have, spend the rest 44 hours polishing and making the game enjoyable.

Responsabilities:
- Local multiplayer and work on mapping game controllers to characters
- UI animations and tracking of points
- GameController for score, deaths and spawning items
- Inventory system and object interaction
- AnimationController for any object on any specified event
- Player spawning
- Environment threats
- Lead a team of 2 other programmers and review their tasks

We received the opportunity to visit Funday Factory, a game company in Aarhus, where we got information from the people there on different tweaks we could do to improve the game and to make our vision into an actual full game.
Later on, a smaller part of the team that was interested to continue in the project spent a week and implemented the features and bugfixes we realized we needed. The game is now in 1.0 and is one of my most proudest achievements.

Credits for 1.0:
- Austeja Vaicyte | Lead Artist
- Mark Nielsen | VFX and Programmer
- Theodor F Purcaru | Lead Programmer

Later, as part of yet a smaller part of the team, we worked towards finishing all of the ideas we had, making the game more enjoyable, creating a trailer and releasing it on kartridge.

Credits for 2.0:
- Austeja Vaicyte | Artist
- Theodor F Purcaru | Programmer

• Download Here

Go Back

Far Lobby

Download here

With this project, we created a ragdoll based game where you drag people either to hell or heaven, and pay the price for it. The game has a straight forward style to it and as such the development reflected that. Our work was not required to encompass many features, but simply make one and perfect it, adding as much juice as possible.

Responsabilities:
- Ragdoll implementation
- Level setup and prefab creation
- GameManager to keep track of choices and score
- SceneManager to switch between scenes as well as play required animations
- AnimationManager which would trigger any event specified in the inspector on any event it would be attached to
- InputManager to give the ability to move characters by dragging them around the screen
- Lead a team of myself and another programmer and review tasks

• Download Here

Go Back

Far Too Much

Download here

This game was made during one of the first game jams I ever participated in. It's a infinite platformer with pre-made chinks of levels which are loaded in randomly as the player keeps going up, giving the illusion of an infinite level while still guaranteeing interesting and fun level design.
The game also has a nice feature where the difficulty is directly proportional to the music intensity, the more intense the song is, the more threats get spawned and the faster the main threat goes towards the player.

Responsabilities:
- Create functionality to get the intensity of a song and spawn threats accordingly.
- Create level section spawner as the player moves.
- Create sanity system which would act as the health of the game.
- Create pickup items and functionality for them.
- Create traps that player can use, such as confetti canons.
- Music player functionality which can use music from the players device.
- Port to android with multiple control schemas.

• Download Here

Go Back

Glitched Construct

Download here

During the '#createjamfall2019', I participated solo and decided to make a third person game, with a heavy emphasis on platforming. I ended up not being able to publish the game before the deadline but I got around to finishing it eventually. The idea for the game is that in a perfect simulation, you appear as a glitch in the system and try to find your way out. Through the game, it would later be visible that you're not the first glitch, and that the system itself might be making you for a reason, which would be later revealed.

The player has four special abilities that they can switch between:

- FORCE | the player can pull objects and then throw them, once they hit something any enemy in the area will focus on that object.
- SHIELD | the player can invoke a sphere around them which blocks all attacks, if the attack hits in the beginning of using the shield, the bullet hits back in whoever shot it.
- SLOW | the player slows down the whole world around themselves, making it possible to run through a room full of enemies or slowing down environmental threats.
- SWORD | the player can either slice enemies or warp to an enemy, instantly killing them over a distance.

The game also has different ways for the player to move around, such as wall running, jump pads, stealth walking and different types of platforms and doors to hack. I also built an extensive settings menu which allows to volume control, switching fullscreen mode and inverting the mouse/gamepad camera controls.
It also has a respawn system where if a player falls down, the last recorded safe spot they were on is used to respawn on, as well as taking away some of their health.

• Download Here

Go Back

Haptic Glove

For my Master Thesis, I developed a haptic feedback glove based on work done by people such as Thad Starner. The work was separated in two semesters, in the first one we focused on Grounded theory, where we collected rich data to try to understand saxophone players and their problems. This was done through interviews and observations I led, as well as a number of surveys. We took all of the collected data and generated a Thematic Analysis which was crucial at knowing what we wanted to specifically target with out solution the next semester.

During the second semester we went through a lengthy design phase until developing the final version of the project. I interviewed experts in the field of playing the saxophone, electrical engineering and design. They helped bring in context and answer the questions that came through the iterative process.

I built the glove using an Arduino Nano for all of the logic, pressure sensors to detect the movements of the user, coin motors to give haptic feedback, leds to guide the user and a bluetooth BLE module to send data to an Android app. The app was used to improve the capabilities of data storage and debugging but after different feedback I expanded it to allow users to setup and calibrate the glove as well as recording and replaying movement patterns. We conducted a number of interviews of people using the glove, where they would try to either follow along, the vibrations being continuous until correct, or simply feel a whole pattern move without any interuption and try to see if they could memorize or understand it. The results were discussed in the final research paper.

Go Back

Hearts Lost

Download here

During fall of 2017, my girlfriend and I decided to participate in AsylumJam2017, her as the artist and I, of course, as the programmer. The game we made is an atmospheric exploration game where you try to survive, go through different levels, and figure out a way out of it for good.

Responsabilities:
- Create a state machine for the AI who can run from or towards the player, be idle, patrol and attack.
- Create a level generation code which uses parts created by the artist set in different categories (such as "wall decoration", "floor decoration", "story element").
- Create ability for user to drain AI of life.
- Create behavior which can be extended at any time using the command pattern.

• Download Here

Go Back

Hurt

Download here

For the MiniJam65 I made a narrative driven game where the player slowly explores their environment in hopes of figuring out what is happening. The whole story would have had the player eventually discovering they had died and the entire gameplay section being a sort of Limbo, where his guilt and self-hatred would keep him in a constant loop.

The game uses asynchronous scene loading to quickly change and merge scenes, this helps with having as many interactables and details as I would want to place, since the area would be small and self contained. It also has a rain shader I wrote in Cg.

The interactables function with contracts. This architecture allows me to expand and create anything for the player to use quickly and was very helpful to get something functional quickly during the gamejam.

• Download Here

Go Back

Mars Initiative

Download here

I finally got to participate in Ludum Dare. My entry was a basic resource management game, which the player can really only interact with by tapping/clicking on the screen. I originally released it on PC in the first day of the contest, and spent the rest of my time fixing it and releasing it on Android.
The game itself is easy to play and very serene once you get in the groove of things. As a colony manager, you need to send factories down while managing available space and fuel.

I later came back to the game and added more features such as different planets, laser cannons, station animations and fixed the menu to work nicely and more android devices.

Responsabilities:
- Make basic behavior for orbiting around celestial objects
- Make autopilot behavior for the missiles traveling to a target
- Make score and fuel tracking functionality
- Make laser fire using raycast to decide on length
- Implement different planet types

• Download Here

Go Back

Small Town Magic

Download here

We made this game for NGJ2020. It's a simple city builder with Tetris-like elements where each structure comes in form of a card available for the player to use. The idea is to build beautiful towns, and experience the procedurally generated story at the end, based on the people who live in the town.The player starts with a set amount of money and must balance out costs of certain buildings with income from others. These values get affected by the decoration structures and by the amount of homes in a town. The game ends when the player enters bankrupcy.

Functionally, the game is centered around a grid-based map, each structure occupying one to more cells. There is a simple day/night cycle using post-processing and each 24 ingame hours, money is added to the budget based on the amount of homes and their satisfaction. Each home placed by the player is procedurally generated based on a list of pre-made parts and it also contains a family formed with a small bio and family name. At the end of the game, a small story is generated from the different families, based on their satisfaction levels.

Credits:
- Austeja Vaicyte | Artist
- Theodor F Purcaru | Programmer

• Download Here

Go Back

Space Race

During CreateJam21 we made a multiplayer game where players have to collect items placed on a rotating station in space. They can bump into each other, lay traps and have to collect the most items until they're all gone. Their characters are picked randomly out of 3 premade ones. A fish, an alien and a tablet with my face on it.

The networking is done using Mirror, which is a library that acts as an abstraction allowing for the develop to focus on behaviour scripting. It functions similarly to Unity Networking, Photon etc. One of the more complex elements was the rigidbody setup of the player, showing properly for each connected user as well as responding to hits, being pushed back. This was achieved using a server authoritative setup, where the players send the input and the physics are only simulated on the host player.

I focused on making the experience comfortable for users, informing them if they'd have problems with connecting, when they'd connect, someone else joining the server and other quality of life features that make multiplayer games like these playable. Similarly the match has a clear start and end, showcased both through the UI as well as a giant shield around the station which dissappears when the game begins.

Credits:
- Austeja Vaicyte | Artist
- Theodor F Purcaru | Programmer

Go Back

Swing Macabre

Download here

We made swing macabre for one of the few online jams I've taken part in. This game is a third person shoot-em up where a jukebox fell from the sky and is turning people into undead swing dancers, the infection is spreading and you need to keep away before you catch it too.

Responsabilities:
- Make a state machine for the AI which can follow/attack the player, idle, go towards the jukebox, dance around it.
- Development on player functionality from animation control to movement and shooting gameplay.
- Spawning AI at an increased rate as the player goes through waves of enemies.

• Download Here

Go Back