RedDragonMakesGames

  Keeping On: The concept: This was a minigame that evolved quite a lot as I made it. I started with the idea of some sort of autoscrolling survival game, where the terrain for the player moved from right to left and the player's goal was simply to live as long as possible. The details of how this were going to work I wasn't sure about however, and so I started with my main goal, getting randomly generated terrain to scroll towards the player and doing so in a configurable way. The challenge:  Drawing the road was an interesting challenge; I've previously done similar random generation based on applying a random change to the current height, but doing that here efficiently is something that would take a bit more thinking. Doing this on a pixel by pixel level would obviously involve a lot of storage (one variable for every pixel in the width of the screen), so I wanted to do this more efficiently. I also had the scrolling aspect to consider. To solve this, I had a list of lo

  Seek and Shoot: The concept: Last week I made a minigame in Unity, so this time I wanted to make a minigame in Unreal. Although I haven't completed a major project in Unreal yet, I've been learning about developing with Unreal and in particular blueprints as a way of defining gameplay behaviour. For the gameplay itself, I decided to build on the first person example in Unreal, and make a game where you had to search around a play field to find and shoot a red target. The challenge: Starting with the first person template helped a bit with setting up the game, but there was still plenty to do to adapt it to the game I wanted. For example, I didn't want the player to have to pick up the gun, so instead I edited the rifle's blueprint to bind to the player on game start. To create the target, I created a prefab, and then wrote a blueprint that would handle when it was hit. To keep track of the score and the time, I created another blueprint class that would store variable

  Hair of the Wolf First level gameplay Hair of the Wolf is a randomly generated 2D platformer made in Unity. As part of the team, my role was enemy and boss design and implementation, random generation and paralax and camera control as well as many smaller programming tasks such as character interaction and damage hit/hurtboxes. The assets and code for the project can be found at https://github.com/RedDragonMakesGames/Gamejam2022 . Gameplay clips:

  A Header the Game: The concept: I wanted to make a minigame in Unity this time; although python is great for getting things moving on a screen, I wanted to practice Unity's game object based style for a minigame rather than a larger project. Seeing as football is topical at the moment, I was considering doing something football related, and after coming up with the title I had to make it. For the gameplay itself, I decided to use some of Unity's 2D physics for keeping a football up, which gave me a chance to use physics materials, which is something I hadn't really looked at previously.  The challenge: Making a minigame in unity is (obviously) pretty different to making the same game in python. Rather than considering the core parts of programatic gameplay, such as rendering and input, Unity will handle most of that behind the scenes. Organisation is also completely different, as you're writing code based on objects it will be attached to, rather than at what point in

  Aim of the game: The concept: Apologies for the late post on this one (this being the game I made on the 28th). The reason for that (and why this was a smaller minigame) is because I was taking part in a big gamejam project due later that week, so expect a post about that soon. That being the case, I decided to go for an aim trainer type game, where the player has to click targets as accurately as possible.  The challenge: The biggest issue for making this game was making sure that the hitboxes of the targets were correct and so every click would be correctly registered. Most of the hitboxes I've used previously have been just that: boxes, whereas the targets are circular. I first considered doing circular checking within pygame, but soon arrived on a better solution to avoid tricky mathematics. Instead of scoring based on hit boxes, I'd score based on what colour the player clicks on. This meant that rather than having to calculate hitboxes I could simply define colours and