Secret Santa website
A Vue.js / Flask website for family Secret Santa events
Every New Year, we have a Secret Santa family event. One day we decided to create a personal website where people can sign in and join the event. When the event starts, its admin runs the sorting algorithm, and the app sends emails to all participants with a person to whom a participant needs to give a gift.
It is my first website project that I created from scratch. I decided to try Vue.js for the frontend and Flask for the backend. Almost immediately, I discovered how many different technologies I need to use to create a relatively simple website. Need to keep a user session? Here is Flask-Login. Need to share user state between Vue controllers? Here is Vuex. And so on.
The sorting algorithm uses backtracking search in a graph. I wrote an article about it.
Technologies used (yes, I listed every single one): Python, Flask, Flask-CORS, Flask-Login, Passlib, SMTP, JavaScript, Vue.js, Vue Router, Vuex, Axios, HTML, AWS EC2, nginx, DNS Records, Certbot (Let’s Encrypt).
The backend project was created together with kath-leen.
Source code: The frontend code at GitHub, The backend code at GitHub
Cuckoo in Isolation
An UE4 text game with dynamic narrative developed for a game jam
Cuckoo in Isolation is a small text game made for a game jam. In the game, a bird with the name Cuckoo must survive in self-isolation. Each game day, a player makes decisions, what Cuckoo will do to maintain her well-being and mental health. E.g., she can start a blog, start a hobby, subscribe to Flexlix, get a pet, or buy a gaming console and participate in holy wars for the best gaming console on the internet. Each turn, something bad happens that can affect Cuckoo’s well-being. If a player survives 30 days, it’s a win. If well-being is 0, the game ends.
The game’s main feature is the dynamic narrative. The player’s decisions can change the game state. The game uses this state to determine which options are available to the player and what random events can happen. E.g., if Cuckoo has a blog and a pet, there might be an option to write a blog post about the pet. If Cuckoo has a subscription to a video streaming service, there might be a random event when her favorite series is closed because of bad ratings.
Technologies used: C++, Unreal Engine 4.
Source code: GitHub
Daily TeleFrag data analysis
How I downloaded all data from a website using its API and analyzed it
DTF (a.k.a. Daily TeleFrag) is one of the most famous Russian websites about games, movies, and popular culture in general. It has API, and all users and posts there have incremental identifiers. It means I can write a script to fetch all public users and posts data one by one by requesting IDs starting with 1 and up to the last registered user or last written post. And I did it.
API has a limit for requests per second, but I managed to copy all users and posts data to my local database. I parsed raw JSON responses and wrote them to PostgreSQL tables as regular columns. After that, I could use SQL to process the data and make some conclusions about the website’s audience and content.
E.g., this is a graph of new users per week.
There are definitely some anomalies here, so this way, I detected some bot attacks on the website.
I wrote a series of articles about DTF data analysis (in Russian), which were quite popular on the website.
- Analysis of users with open data
- Analysis of posts and subsites with open data
- How I found hidden subsites with open data
Technologies used: Python, PostgreSQL.
Source code: GitHub
Binary machinery website
A website/portfolio/blog powered by Jekyll and hosted at GitHub Pages
One day I learned that GitHub has GitHub Pages, and that I can use this service to create a static website. I thought I would make a cool static blog/portfolio website; I just needed to create a repository, install Jekyll, pick a UI theme, and GitHub will do the rest.
Apparently, I was wrong. Yes, GitHub Pages are cool, and deployment went smoothly, but I had to write a bunch of layout files for Jekyll manually, which are a mix of HTML, YAML, and Liquid templates. At least it works, and you (most probably) are looking at it right now.
Technologies used: Jekyll, GitHub Pages, HTML, CSS.
Source code: GitHub
Slower Than Light
A game for Finnish Game Jam 2020 powered by Unity
Slower Than Light is a game for Finnish Game Jam 2020 (a Global Game Jam branch). The theme was “Repair,” so we decided to create a game about an alien trying to get to his home on a constantly breaking ship. To fix the ship, a player needs to solve puzzles. The puzzle is an alien ship device. Each device contains a set of pieces that are supposed to look like alien technology.
Once in a while, a device breaks, and some pieces fall off. To fix them, a player needs to put the pieces back to their original places. We wanted to create a feeling that the player doesn’t understand this alien technology but somehow fixes the devices.
Team
- binary-machinery (me): puzzles logic programming, puzzles gamedesign
- fstleo: ship logic programming, player controller programming, lighting and rendering settings
- i7enin: 3D-models, visual design
Technologies used: C#, Unity.
Source code: GitHub
Beat Saber modding
How I reverse-engineered tools for mod injection into Unity games and created my own mod
Beat Saber is a popular VR game powered by Unity. A significant part of its popularity is because of its modding community (BSMG). One day I decided to write my own mod, but before it, I wanted to learn how mods are made for Unity games.
I reverse-engineered tools for mod injection into Unity games (BSIPA, Unity Doorstop). They use various tech tricks, e.g., game and engine libraries modification, DLL input address table hooking, and Mono Runtime hijacking. Then I developed a simple mod that shows the amount of time spent in the current game session (both total and active).
As a result of the research, I wrote two articles about mod injection and development.
- How mods are made for Unity games. Chapter 1: Inject mods into a game’s code
- How mods are made for Unity games. Chapter 2: How to write a mod in C#
Technologies used: C#, Unity, C# decompiler, C, BSIPA, Unity Doorstop, Mono.Cecil, Harmony.
Source code: GitHub
Generative Music
Experiments with music theory and music produced by algorithms
Generative (a.k.a. procedural) music is music created by a system, music created by algorithms. Inspired by some works of Brian Eno, I decided to implement an app to produce generative music. I studied music theory at that time, so I tried to use some fundamental music ideas in the app. E.g., if chords are played in a key (e.g., C Major), they most probably will sound good.
The main issue with the project is that generated melodies sound almost the same. Apparently, it’s not that easy to teach a computer to produce music with just random numbers. E.g., a key doesn’t only mean that there is a particular set of chords. It also means that there is a particular root note that tends to sound more often than the others. But how much more often?
We need to either use machine learning here or use some manual weight coefficients for root notes. The first one looks like the job for Google, Apple, Spotify, or another company with an immense amount of music data. The second one sounds like too many manual coefficients to make it sound good. So, the project is frozen at the moment.
Technologies used: C#, Unity.
Source code: GitHub
Disaster City
An RTS prototype for a game about giant monsters destroying your city
I had some design ideas (and still do) about a strategy game where a player protects his/her city from kaijus, UFOs, titans, and other giant monsters. This project is an RTS prototype with the real-time unit and resource management.
A player must call and control units manually. The prototype has two types of units (tanks and airplanes), one ability (artillery strike), and one enemy with a simple logic state machine (attack the city, attack units, block attacks, and rage).
The prototype showed that RTS that relies heavily on micro-management is not a very good idea. I think that a city-builder with indirect unit control would fit the story better.
Technologies used: C#, Unity.
Source code: GitHub
Dystopian Horror
A short horror-game where the environment changes when you don't see
Dystopian Horror is a short horror game I developed in Wargaming Academy. It was inspired by Layers of Fear. Its main feature is that some pieces of the environment change when you don’t look at them. E.g., if a player enters a room, it moves to another place to confuse and scare the player.
Each room is a Unity scene. The game controls the environment by loading the scenes in the additive mode and moving them when particular events are triggered.
The project might be considered either a short 5-minute horror game or a demo of a game that will never be released. All visual assets are taken from Unity Asset Store.
Technologies used: C#, Unity.
Source code: GitHub
Vector Tactics
A simple top-down shooter for AI algorithms testing
My master’s thesis was about AI algorithms for video games. Vector Tactics is a simple top-down shooter I developed to test AI architectures. The game has one arena with hard covers (block line of sight and shots), soft covers (block 50% of shots), health packs, and a couple of AI agents.
There are four bots, one for each AI architecture from the thesis: Finite State Machine, Behaviour Tree, Neural Network, and Fuzzy Logic. The bots fight each other in the arena to decide which one is the best. Or which one is better implemented.
Technologies used: C#, Unity.
Source code: GitHub
Avalon Schedule
An Android app to parse university schedule and notify if it changes
I had an issue in my university: a schedule might have changed the day before a lecture, and students might have missed the change if they hadn’t checked the university website in time. I developed a mobile app that loads the schedule, shows it in a format suitable for mobile devices, and sends push notifications if it has changed.
The app loads the schedule’s webpage and parses HTML to get a table from it (there was no public API). Every 2 hours, the app’s background job checks the schedule in the background, and if it changes, it notifies the user about it.
Technologies used: Java, RxJava, Android SDK, HTML.
Source code: GitHub
libmodbus_cpp
A C++/Qt wrapper for a C library for the Modbus protocol
Modbus is a data communications protocol for computer systems, sensors, and hardware actors. It is used for production pipeline automation and SCADA monitoring.
libmodbus is a popular library for Modbus, but it is written in pure C. libmodbus_cpp is a C++/Qt wrapper for easier integration into Qt projects that we were working on at that moment. Since the original library is an LGPL project, we decided to share the wrapper at GitHub.
Technologies used: C++, Qt, libmodbus.
Source code: GitHub
Dijkstra vs. A*
Research on Dijkstra and A* pathfinding algorithms performance
As my course project at the university’s algorithms course, I decided to compare the performance of two pathfinding algorithms: Dijkstra’s algorithm and A*. I was working on a libGDX game prototype called VT at that moment, so I decided it would be a good platform for tests.
I created a navigation graph over a tiled level, implemented both algorithms there, and used some game UI elements to draw all the scanned nodes that algorithms visit before finding the optimal path. It was really helpful for algorithms understanding that Dijkstra’s algorithm scans the navigation graph in all directions, and A* scans it in the direction of the expected target (if heuristics is ok).
Technologies used: Java, libGDX.
Source code: The course work at GitHub (in Russian), The VT branch with the algorithms at GitHub
VT
A prototype for a top-down tactical shooter with movement trajectory control
I wanted to create a mobile top-down shooter game where tactic decisions and information are more important than the player’s reaction. In the prototype, a player can draw a character’s movement trajectory and select the direction of view at each step of this trajectory. This prototype was inspired by Frozen Synapse.
After some time spent with the prototype, I decided that such a control system is too complicated for a mobile game. The selected technology (libGDX) wasn’t very promising and popular to continue development with it. The game idea had some game design issues. So, in the end, I decided not to continue working on the prototype.
Technologies used: Java, libGDX.
Source code: GitHub