square--circle--triangle

[square--circle--triangle]

Making my title screen

I wanted to go with the same approach as my last project for the title screen and make it in Unreal Engine. However, due to the nature of my game with it's quirky camera I thought it would be easier to make it in a new level.

To keep the arcade theme going I wanted a simple and appealing piece of artwork that showcased the game with the title, and a prompt to start the game, as this is what a lot of old arcade games did:

In my new level I used static meshes of my assets to make a simple screen. I also played around with a fountain Niagara System, which is Unreal's Particle system:

I then added this to the back of the ship to simulate it flying- it doesn't make sense for the particles to be moving in a static image but I think the movement attracts the player to the title screen.

In my new level I also had to remove the PlayerStart and remove the default player pawn so my player didn't spawn in.

I ran into a problem setting up the camera during this process. I initially tried to set the camera in the level blueprint, but I couldn't get a reference to my camera actor. I eventually found this setting inside of my camera that fixed my issue:

The last thing I did was add an animated widget, using the same method as my game over screen to make it flash.

This was the final result:

Given how quickly I made this I'm really happy with the result- it looks like a modern arcade game.

[square--circle--triangle]

Unreal Engine: healing

I thought that it was kind of unfair that my player isn't able to get any health back after taking damage, and getting extra lives/health for playing well is a staple in most arcade games. Because of this I made a feature that heals the player if they don't take damage for a period of time:

This custom event is called at the start of the game and whenever the player takes damage, so it's always running. At the moment it's set to 5 seconds, but I think a time of 25-30 would be more appropriate- I don't want games to drag on for ages/become too easy because of this.

This was a really simple feature to implement, but I think it makes the game fairer, rewards the player for playing well and gives them more agency in their runs.

[square--circle--triangle]

Bug fixing and tweaking

Some of my projectiles and enemies weren't despawning when they flew past the player:

To fix this, I multiplied the normal vector by a bigger number and moved the enemies' fly away scene further back, so they both moved further and hit the kill wall.

------------------------------------------------------------------------------

Whenever an enemy spawns, their spawn timer gets reduced by 0.05. Eventually that number becomes 0, and this happens:

Obviously this is unplayable, but this bug gave a really cool idea of a 'swarm' mechanic, where the enemies come in really quick for a few moments. I both added this feature and fixed the bug like this:

I also added the same code to the asteroids to make them more fun as well.

------------------------------------------------------------------------------

Whenever my player dies, they can immediately restart the game if they press any button. This can be jarring and the player may reset without meaning to. To fix this, I had my death actor temporarily disable inputs when it spawns. I also had it show the game over screen after a delay, because I thought that made it look better:

[square--circle--triangle]

Creating my enemy model

I wanted to go for a spherical shape for my enemies, and wanted them to make sense to be in space. After some thinking, I thought I could do something like the probe enemy from Terraria:

In Maya, I added a sphere and reduced the amount of subdivisions to get a low poly sphere:

Then I created a UV map for it in Photoshop, It's basic but the player will only be seeing the front of the probe so I didn't spend time making anything beyond that:

After applying the texture, it looked squished down so I had to mess around with it's scale, but after that I just had to import it it into Unreal Engine.

The enemies had big shadows on them during gameplay, So I decided to mess around with their material using Unreal Engine's built-in material editor:

This gave me a result I was happy with, and in-game the enemies looked like this:

[square--circle--triangle]

2nd wave of feedback

For these questions I wanted to make sure my game met the standards of the brief in the eyes of new players, and I also wanted feedback on my enemies.

These questions were all linked to different specifications of the brief. Based on these responses I think my game does meet it's criteria.

These questions were about my game specifically. I was shocked by how positive the feedback was in regards to the aiming- people seem to think it's difficult but fair. The other feedback I got regarding new features or visuals is very valuable as it tells me what players think would make the game better, however some of the more demanding features like power-ups may be out of my scope.

[square--circle--triangle]

Unreal engine: Creating my enemies

This is one of the last big features I had planned to add in my game. I want my enemies to:

Spawn offscreen

Move into the players view

Move to random points on screen

Shoot the player

Fly off screen if not killed in time

for the first 3 points, I went for a similar approach to my asteroids and created a separate manager actor for their spawning. I added 8 scenes where I wanted them to spawn and a small collision box for where I wanted them to move to. This is the code for getting them to spawn:

This worked, but I ran into a problem with the enemies themselves- I couldn't get a reference to the manager's box. After realizing this I tried to make them move to random vectors based on the dimensions of the manager's spawn box- but this was difficult to visualize and hard to program.

Instead, I managed to get a reference to the manager by creating a bigger collision box and having the enemies spawn in it, then used the ActorBeginOverlap event:

This worked, and now I could use the same method I used for my asteroids to move the enemies around:

This was my first time using the Move Component To node, but it was very self-explanatory. This worked and I had enemies moving in my game.

Making the enemies shoot was a lot harder. After making a new EnemyBullet actor I made this blueprint which just moved it to the player:

This obviously didn't work as the bullet stayed in place when it reached the player's position. I could have made it destroy itself but that wouldn't have looked nice- I wanted them to fly past the player. I tried to add to the player's location, but it still didn't work as at certain angles the bullet wouldn't fly offscreen:

After some thinking I tried messing around with the ProjectileMovement component:

However the homing was either to strong that it followed the player too much, or too weak that it didn't go in the direction of the player.

I found my working solution after finding this forum post: Move object towards player? - Programming & Scripting / Blueprint - Epic Developer Community Forums (unrealengine.com)

One of the replies had a very detailed guide on how to do what I wanted, which included the use of the Normalize node. This turns a vector into a unit vector with a length of one, which I could multiply to send the projectile in the direction of the player at different magnitudes of distance.

The final thing to add was enemies flying past the player. I did this by giving the enemy a MovementsLeft variable, and decrementing that by 1 every time they moved. When they have no movements left, they fly to the general area of a scene I put into the enemy manager which is behind the player.

After that the code for the enemies was done, and this was the final result:

It still needs some polish (and a model) but overall I'm really happy with how this turned out.

[square--circle--triangle]

Unreal Engine: adding visual effects when things explode

This is something I forgot to document when I added it, but it's pretty simple. I created a new actor that plays a flipbook of an explosion I made:

Then I have that actor spawn whenever the player or an asteroid dies- making sure it's scaled appropriately.

I like the mix of 2D assets in the 3D space and I may do this for other vfx in my game however I want to experiment with Unreal Engine's Niagara system aswell so the final result may be a mix of both.

[square--circle--triangle]

Creating a game over screen

Now that my player can die, I need to add a game over screen to flesh out the game and allow the player to retry.

I wanted to go down the route of simple arcade cabinents and just have a flashing piece of text- I achieved this by animateing a widget using constant key interpolation- which instantly jumps between keyframes instead of tweening towards them.

This allowed me to create the effect like this:

Then I needed it to appear when the player died- which was simple enough:

The biggest issue was actually getting the game to restart when the player presses a key. At that point ingame the player actor is dead so it wouldn't recieve inputs- and I can't have a piece of code that resets the game when any key is pressed running during gameplay.

My solution to this problem was to create a new actor that spawns when the player dies, and resets the game when the player presses any key.

This didn't actually work at first as the actor wasn't recieving any input. After some research I found this forum post https://forums.unrealengine.com/t/keyboard-event-not-working/484194/7 which had a similar issue. Turns out the fix was a box that's disabled by default:

After changing that it works fine- and I'm happy with how it turned out. It's simple, but blunt and aggrevating enough to encourage the player to try again.

[square--circle--triangle]

Making my player's crosshair more accurate

The biggest problem I had with the crosshair is that it was placed between both firing positions, rather than from the ship's cannons.

I duplicated the crosshair so that one came out from both cannons and this is the result:

While this was ok, there's still a bit of uncertainty about where your bullets will go in the middle.

The last change I made to this was I multiplied the bullet size by 10. this was probably the most simple thing I could do and just helps the game feel fair.

[square--circle--triangle]

Making changes to my game based on feedback

One problem that I have when making a game is being so used to the controls/mechanics that when I add something that would be totally unintuitive to the player- this fact would be lost on me. To alleviate this I want to have regular playtesting by fresh players throughout my game's development.

This first week of questions isn't anything major- I just wanted to make sure everything makes sense to the player: my only concern was the crosshairs.

I was expecting this kind of response to these questions- and I don't think I have anything I need to change here.

I was happy with the responses given here: I'm trying to stick to the arcade style throughout development and it seems like players can see that.

This is what I wanted feedback on the most: the aiming. Based on this, I definitely need to find a way to make it clearer to player where they are aiming, or make it easier to hit asteroids.

Most of these responses are useful and all link to a common theme: more should be happening in the game. I think powerups and increasing difficulty are good ways to do this, so I'll definitely look into those.

[square--circle--triangle]

Unreal Engine: Giving my player a health bar

Like most games, I want my player to be able to lose: This would happen when they run out of health.

The style of health bar I want again goes back to Star fox, using a simple bar:

This is a nice method as it allows me to have more control over my players health- the bar could represent 100 hits with different enemies doing varying damages.

I'd also like the health bar to go from green to red as the players health goes down.

To start I made a new Widget and added a progress bar:

Then I bound the percent to the player's health (a float from 0-1):

This will cause the bar to change how full it is depending on the health- the closer to 0 the less full it will be and vice versa.

Inititially, I couldn't get the health bar to be as smooth as I wanted- I tried to interpolate 2 colors and bind it to the bar's color:

This didn't work for some reason, as it only went between green and yellow.

After some more attempts, I decided this isn't a feature I want to spend loads of time on, as it should be quite simple. Because of this, I went a simple flat blue, to match the color of my player. I also added some text to show the player what it is:

the only thing left to do was to create the logic for the player taking damage and dying. I wanted the player to have a moment of invulnerability between hits, and for them to flash during this to communicate the feature to the player.

The invincibility was easy enough to add- it was just a Bool that said if I could take damage or not, but I couldn't get the flashing to work. I could get my player to disappear and reappear but if I tried to do multiple back to back, it just wouldn't work. These were my 2 attempts at this:

The worst part is I'm not even sure why they don't work- they look like they should.

Aside from that, adding the rest of the logic for the player's health was fine and looks like this:

Overall, I'm not very happy with how my health system turned out as I had to cut some corners due to me being unable to properly implement some mechanics. If I have time I definitely want to revisit this feature and improve it. Something I could definitely try is having the health bar be a static gradient to add some flair to it, like star fox 64:

[square--circle--triangle]

Unreal Engine: Creating a highscore system via saving

Like any self-respecting arcade game, I'd want my game to have a highscore so players can challenge themselves to beat each other.

To do this I need a Score variable on my player and a Highscore variable on a Save Game actor:

Then I need to make a widget and create 2 text blocks, binding one to the score like so:

Now I need to set up the highscore and make sure it saves and loads. This code will create a save game if it doesn't exist, or load a saved game if it does (this is called off of Event BeginPlay):

This code will overwrite the highscore variable with the valuable of the players score and save it. No event fires this code yet in my game, as there isn't a way to get score. I could fire this whenever my player gains score so it would update in real time, or I could fire it whenever my player dies- both ways would work.

The last thing to do is to bind the highscore to the HUD like so:

I also changed the font by creating a new Font asset and Font Face to assign to it.

This is the final result:

It's basic, but effective so I'm happy with the outcome. This makes my game more arcade-y and will help encourage people to play my game as it gives them a target to beat.

[square--circle--triangle]

Unreal Engine: making my asteroids spin

to give some life to my asteroids I wanted them to spin while they move towards the player, to further give the illusion of being in space.

I initially had the asteroids add a random rotation between -1 and 1, but because this number was re-rolled every tick, it just caused it to have a seizure:

To fix this, I simply assigned the random rotators once, when the asteroid spawns. For some extra flair, I also multiplied their speed when they split up (this is also where I discovered you can convert an integer to a Boolean with 0 = False and 1 = True, which is really useful).

The end result was exactly as I hoped, so I'm pleased with it as it is although I'm unsure how it will look when I add It's final texture/model.

[square--circle--triangle]

Unreal Engine: Giving more logic to my asteroids

When asteroids are shot in my game, I want them to play exploding vfx/sfx, and also split into 2 smaller asteroids. I could have a separate "baby asteroid" actor spawn, or I could have it spawn itself, just smaller.

I initially used a macro for this, which are like functions in regular programming (taking inputs and giving an output): which looked like this (the code wasn't finished at this point but the purpose is clear):

I later realized that the macro was useless for the purpose I was using it for: it was literally just a branch.

After changing the macro, changing some numbers and making it spawn 2 asteroids, I had this blueprint:

It looks complicated but all it does it check if the asteroid hit has been hit before. If it has, it destroys it. If not, it creates 2 smaller asteroids near itself- then destroys itself.

This works, however there is a chance the asteroids will spawn inside each other, which doesn't look right. Unfortunately, I can't find a fix for this, as changing the collision handling doesn't seem to do anything.

Aside from that I'm happy with the result, and I now just need to add the vfx/sfx, which shouldn't be too hard.

[square--circle--triangle]

Unreal Engine: adding a deletion wall

To save memory and reduce lag, I've added a collision wall to both sides of the play area to delete actors that are out of the players vision:

This was really simple to implement but I imagine it will greatly reduce lag if the player plays for a really long time as it stops the build-up of actors.

[square--circle--triangle]

Unreal Engine: messing around with different ways of aiming

Due to the nature of my game, aiming can be hard as it's hard to get a sense of depth. To combat this I had 2 ideas: homing projectiles and crosshairs.

Homing Projectiles:

Unreal engine has homing features built into the ProjectileMovement component, so I played around with them for at bit: my goal was to give my bullets a subtle home to assist the player without turning the feature into something they could crutch on.

However, this didn't work the way I intended, the homing was either too strong or too weak- which caused this bizarre effect:

I then tried playing with the speed/homing strength of the projectiles at different times during it's lifespan, but again- I had the same issue.

Currently, I can't find a way to have the projectiles home in a fair way, however the stronger version could definitely be used a powerup of sorts, if I decide to add those.

Crosshairs:

A simple crosshair wouldn't work for this as the projectile wouldn't be accurate to that point. Instead I wanted to create something similar to Star Fox 64, where the player had both a short-range and a long-range crosshair:

To do this I first needed to create a widget that would become the crosshair, which was simple enough:

Then I needed to add it to the screen. Instead of doing it in a blueprint like normal, I can actually add it directly to my player character in it's viewport:

This was much easier, and after some tweaking the distances multiple times I'm very happy with the result. However, as I've been testing this for so long I definitely want other people to playtest it to get the opinion of a fresh set of eyes.

[square--circle--triangle]

Unreal Engine: how my bullets interact with asteroids

When a bullet overlaps with a asteroid, it deletes both actors and adds to the score. This works, however this logic is inside of the bullet instead of the asteroid and as I want more things to happen after the overlap, I think I should move this code.