Unreal Free For The Month Jam // September 2023 - Escape The Palace Hall

What is Free For The Month Jam?? I explain it all here in great detail:

https://lptcp.blogspot.com/p/free-for-month-jam.html

Basically, it's a game jam I made up where you have to use the current Unreal Free For The Month Assets to do, something.

It's called a jam instead of a game jam because you don't have to make a game. It can just be a simple mechanic. Whatever floats your boat.

This month I sat down and was actually able to complete my own jam for the first time since I started it almost year ago.

My entry this month came from ChatGPT which told me to create:

So that's what I did. And I made it into a video:

It's very basic, but I really struggle with finishing projects so I was proud I managed to get this to a packaged state and was happy to call it finished.

I ended up creating a very small game that requires you to find 2 items, pick them up and place them on pedestals to unlock the doors. If you don't do it within 60 seconds, you lose. It features a grab mechanic and a simple interact mechanic with the doors, as well as two trigger box events that cause spooky things to happen. I then added some sounds and music for ambience.

Keeping the scope small was really difficult and hopefully I'll be able to complete next months faster.

[Dev Log] Generic Slenderman Clone Part 2 // UE5 & Blueprint

So after part 1, I had the bare bones of a slenderman game. In this part I wanted to flesh out the mechanics a little more and make it start to look more like a "game". My Goals for part 2 were:

1. Replace the cubes with actual "notes"
2. Create random spawn points for the notes
3. Create a sprint mechanic + realistic jump
4. Add sprint and notes to HUD widget
5. Change it to night time
6. Create a flashlight
7. Create a battery mechanic
8. Executable

1. Replace the cubes with actual "notes"

2. Create random spawn points for the notes

For this I opened up blender and made the shittest piece of paper. Took about 1 minute. Made sure to resize the plane to A4, curled the edges slightly and gave it a material slot for the front and back and then exported it to Unreal.

I downloaded the note textures used in one of the slenderman games off google images and created materials from them. Then created a way for the notes to pick one of the materials at runtime. There are 8 different textures and each note is unique:

I created a new blueprint which now handles the spawning of the notes and what material they get. This blueprint contains 16 locations where the notes could spawn. More can be added but only 8 locations will be picked at runtime. You can change the number of locations in the details panel in the editor.

3. Create a sprint mechanic and realistic jump

Default unreal man jumps like Princess Peach; in fact it's more floating than jumping and greatly annoys me. Fixing it is quite simple though by just changing the Z Jump Velocity in the Character Movement.

The sprint mechanic is also relatively simple. When shift is held, it reduces the sprint each second and when it reaches 0 (from 100), you can no longer sprint. It takes 10 seconds to replenish fully. I achieved this by using timers instead of ticking. That way, we're not constantly checking to see if we're sprinting (or replenishing sprint value) every frame; only when we need to.

4. Add sprint and notes collected to the HUD widget

Using icons from the Android library (they're free to use) I added a progress bar and text to the HUD:

The progress bar does use a binding to update itself which is expensive but barely anything is ticking in this game so I didn't really care. In UE5, the progress bars now come with a default animation as well which is snazzy. The notes text is updated when a note is destroyed and the blueprint sends a message to the HUD.

5. Change to night time

This was one of the most difficult parts as lighting in Unreal Engine is unbelievably difficult. You need to change colours determined by sun, override sky colours, change the post process volume and exponential height fog....it's never ending. Also, as the scene is so dark afterwards; I duplicated BP_Sky_Sphere so I could add a tick box which would allow me to switch between day and night in real time.

In the construction script I added this mess:

Which toggles between "soft day" and night:

6. Adding a flashlight

For this I simply add a spot light to the character and attached it to the head socket so it moves with the character. I thought about a doing a torch you hold in your hand but couldn't be bothered with the hand animations as this is true first person so instead, the player is wearing a head torch. I added some nodes to allow the player to toggle the flashlight on and off with F.

The flashlight is its own blueprint and spawns on the player as a child component. I gave it a light profile as well using one of the default UE ones so it's softer when far away from objects; but then the cone shape starts to appear when you get closer. It always annoys me in games when the flashlight is just a circle in the centre of the screen.

7. Adding a battery mechanic

This didn't take long as it was almost copy and paste on the sprint mechanic. I added some timers to the flashlight so when it's in use it begins to lose power and it updates the HUD with the new power level. I added a cylinder to game which acts as a "battery". When you pick it up it replenishes the battery power; regardless of how much power you have left. So batteries should be used wisely as you can't store them in an inventory.

8. Executable

In the gif, "slenderman" is motionless as I disabled it's "AI" for the moment whilst testing (and I forgot to remove the debug output from sprinting) but it's starting to look more like a spooky game now!

In part 3, I'll actually create the forest map, add sounds like footsteps, cracking twigs and some story elements. By the end of part 3 it will look like a proper slenderman game but it still won't act like one.

[Dev Log] Generic Slenderman Clone Part 1 // UE5 & Blueprint

The next game on my list for the 12 months of games challenge is a straight up Slenderman clone. Slenderman is without a doubt one of my favourite games of all time due to the simplicity of the premise; you are chased around a forest by an A-Posing faceless man in a suit whilst collecting 8 items. I was always more of a console gamer and so I didn't know anything about the "indie" games scene and then 2013 hit with Slenderman and now I can't go back; indie horror games are my favourite genre.

So to ease myself into UE5 (and remind myself of how the editor works); I decided to make a straight up Slenderman clone. Once I've completed this version, I will then remake it using C++ instead of Blueprint.

In total there are 5 stages to this game, in this first part I'll be:

1. Creating the "map" and first person mode
2. Putting notes on the "map"
3. Displaying the collected notes count
4. Adding a way to collect notes
5. Adding "slenderman"
6. Creating a titlescreen and endscreen
7. Creating an executable

So there will be a full "game" by the end of this stage (it helps keep me motivated) but when I say "map" I mean the default 3rd person map and "notes" will literally just be textured cubes from the starter content.

1 - Creating the "map" and first person mode

I've just synced UE5 at work and I did the "Your First Hour in UE5" tutorial from the Unreal Learning portal but other than I've not done much. I will say I like the interface upgrade and the darker colours. For this project I'm using the Early Access 2 version.

I started off with the third person project using Blueprint and starter content. My game will be imaginatively called "Default Unrealman".

I cleaned up the scene a bit by removing the text and moved things into folders. 

I added a hacky "line trace" to my character which is simply just a collision box shaped to a rectangle coming off the players face. It's not very efficient but I'm not making Halo so it doesn't really matter.

"True" first person mode is achieved my simply attaching the camera to the head socket and moving it so it's on the head. The rectangle trace is also connected to the head socket. I set the camera to move with the pawn rotation and then set the pawn rotation to use controller yaw; this way the camera doesn't do a 360 spin around the player but moves as the player moves.

2 - Putting Notes on The Map

I created a new blueprint actor for my notes which simply contains a cube with a texture on it from the starter content. The note contains a text variable with what to display on interaction and a collision box, I then placed 8 of them on the map.

3 - Displaying the Collected Notes Count

For this, I needed to override the current game mode. I created a new HUD class called BP_GameHUD. Then created a widget called W_GameHUD. BP_GameHUD contains a reference to W_GameHUD and a function that allows access to this widget.

With that out of the way, I added some text to the Widget and then added the widget to the viewport.

Currently this isn't interactable but it's simple enough to set up getters and setters in the widget to change this text.

4 - Collecting the Notes

This involved adding the usual "Press E to use" text to the screen whenever the player is looking at a note.  I added a new text component to the hud widget and 2 functions to set and stop displaying it.

Then I gave the note blueprint a reference to the hud widget and called these functions using when overlap begins and ends on the collision box. Now when playing the game it appears in the middle of the screen, directly where the player is looking and disappears when the collision stops. 

To "collect" the note, it removes the actor from the game when E key is released and to update the HUD widget, I added an int to BP_GameHUD and a function to increment which then updates the hud widget.

5 - Adding "Slenderman"

My version of slenderman is an A-Posing default unreal man:

UE5 has a couple of new components that you can add to actors called "InterpToMovement" and "RotatingMovement", however I'm going to do it the old old-fashioned way:

This will get replaced with a behaviour tree later on but for now it's fine.

Terrifying.

6 - Creating a Titlescreen and Endscreen

The most involved part of the process...at least there are widgets this time and I can just drag and move them around instead of manually typing in positions. Bless the editor. I hate doing UI stuff.

After much faffing about creating a new game mode for the menu screen and setting input controls for each screen. I finally had a "working" slenderman game....I mean technically it's a game.

7 - Creating an Executable

This was the most different part of the process from using UE4. Turns out I still haven't installed the Windows SDK on my pc; I've had it for almost a year now. The package and cook is in a completely different place as well and documentation links are broken. Very cool Epic.

For future reference, you need to install the specific .NET framework from here:

https://aka.ms/dotnet-core-applaunch?framework=Microsoft.WindowsDesktop.App&framework_version=3.1.0&arch=x64&rid=win10-x64

Then, just when I thought it was building, I needed to disable the Quixel Bridge plug-in due to some random shared pointer being null. I will say though Quixel did fix it back in October, I just haven't updated the Engine...

But eventually I got my application:

It's beautiful. 

It might not look like much but it's basically the bare bones of the game. Make it night time and add a spooky forest and it's pretty much done....OK maybe not completely. The next stage is to add the flashlight and sprint mechanics and make it night time. Then in Stage 3 I'll create the forest.

UE4 // Book Generator Project

I took a break from C++ programming to focus on something I don't have much experience with; the Unreal Editor. I use Unreal everyday for work but I usually don't open the editor and if I do it's just to test something I've written/modified in C++. I'm not a designer or a gameplay programmer so it's not something I use often.

I decided to come up with a small project that I could easily break down into stages and implement. I like horror games and most horror games tend to have a library in the level. Creating a book and then placing hundreds of them is tedious and a waste of time so I thought a book/library generator would be a nice small and encapsulated project.

After some planning I ended up with 7 stages that started from creating and uv-unwrapping a simple book model to creating a bookshelf blueprint that has books randomly placed when dragged out:

You can drag out this cube and it has 4 different spawn points on it that will randomly spawn, horizontal or vertical stacks of books. They themselves are also randomly spawned.

Stage 1 - Book Creation

I had 4 tasks for this stage; 

1. Create a simple book mesh
2. UV unwrap it
3. Create a texture for it
4. Import it into unreal

I had to re-import it a few times as I kept changing where I wanted the pivot to be and blender's UV map exporter is slightly annoying. My book textures are off by 1 pixel in certain places as Blender can't make up it's mind about hard edges in UV maps.

To create the textures I used a combination of Adobe PhotoShop and an online tool of theirs called Adobe Spark. Spark is fantastic for quickly creating social media graphics as it comes with thousands of templates, free images and fonts. Or well, it's free if you have a CC license (which I do).

The book dimensions are based off a real book off my shelf and the side textures were created by taking a photo of the sides.

Stage 2 - More Textures and a Book Blueprint

This stages tasks:

1. Create 9 more textures for the book
2. Create a way to swap the texture via the editor using a drop down menu
3. When the book is dragged into the editor it will pick a random texture
4. When the book is dragged into the editor it will pick a random scale.

Creating all the textures took me 11 days and by the end I was a bit sick of texturing.

For the next tasks, I became acquaintances with the construction script. Basically, the construction script is run anytime the actor is built and actors are rebuilt on many things:

• Compilation
• Save
• Editor Opening
• Moving/rotating/scaling the actor
• Changing a variable on the actor
• Cooking (building the game for shipping)

It's extremely powerful and useful but also very dangerous. For this I created an enum out of my book covers and then created a random number on construction and used that to determine the book cover. I made these variables public so the cover can be picked manually or set to random by the user in the details panel. I did the same for the scale but only allowed a scale between 0.5 and 1 (1 being full size).

This is pretty comprehensive for a single book but set the foundation for later stages. "Freezing" the settings is a bit complicated as when construction is run, the actor is torn down and rebuilt so any variables on it are set back to default (or whatever they are set to in the details panel). To counteract this I used something called "Random Streams". This way the book is given the exact same seed when FreezeSettings is true, and then when it's rebuilt it will "randomly" choose the exact same random numbers used to set the cover/scale again. When FreezeSettings is false, a new seed is supplied changing the random numbers starting point.

Stage 3 - Horizontal Stacks

The tasks:

1. Create a book actor that is a horizontal stack of books. Allow users to add/remove books to the stack
2. Give the books random scales

This was the hardest stage for me. I started this project on the 10th April and only finished Stage 3 on the 25th July. I had work and other things but I was severely blocked on the stack of books having a random scale applied. I calculate where to place the next book based on the depth of each book added together. This works perfectly, however I was doing this in one place in the construction script:

Yep. I was giving the book a random scale then setting the global bookscale variable with another random scale. I was livid with myself that I made such a stupid mistake. After this progress was much faster and you can bet I triple checked all my blueprint nodes going forward. 

For this you can just drag in instances of BP_HorizontalStack, freeze the settings, unfreeze, set random scales and alt-drag new instances to create stacks of books in seconds.

To increase/decrease the books I set a public slider in the details and then in the construction used a for loop. When the slider changed, it would call to "Add Book", setting the cover/location/scale for the number of books set by the slider. Thanks to the random stream, when frozen, it appeared as though all the settings of the book had been saved when in reality they hadn't.

Stage 4 - Vertical Stacks

The tasks:

1. Create a book actor that is a vertical stack of books. Allow users to add/remove books to the stack.
2. Allow users to align the books left, right and center.
3. Allow random scales.
4. Allow random rotations.
5. "Flip" book so the spine is facing the other way.

The first task didn't take long. I just simple set the rotation of the book to -90 degrees when spawned. This caused all the books to be stacked on top of each other. However they are all very neat with a default right alignment thanks to where the pivot point is. 

To calculate the offsets so they could be aligned differently, I just offset the spawned location on X and Y using 25% of the books length. 

For random rotations I created a random float in the ranges of -90 to 90 degrees on the z angle using a random stream. Again the stream allowed the rotations to be "frozen".

Stage 5 - Stack Extras

The tasks:

1. "Flipped" books so the spines are facing the other way.
2. Rotating some of the books in horizontal stacks

Flipping the books was a bit of head scratcher for me as I realised it was flipping the book at the pivot point so doing a simple rotation wouldn't work. I then remembered that negating the scale of a mesh causes the texture to "flip" without actually changing the scale. Granted the text is backwards if you see it but these books are only, at most, 20cm tall and meant as background decoration so this worked perfectly.

The next task frustrated me for an evening until maths came to my rescue. The next book spawn location is determined by all the book widths added together but how wide is a book when it's rotated slightly? As I drew out the problem on paper I quickly noticed that it created a right-angled triangle where I knew the hypotenuse and theta so I had to use Pythagoras to determine the adjacent (the side of the triangle I was after). I then added that length to my stack length and now it creates randomly rotated books (from angles 0 - 20 degrees) of varying scale:

It's not completely perfect and the end book can end up being rotated as I haven't set anything in place for that but you can just randomise it again. The book rotations are on weighted bools (from streams again, any random numbers use streams) so there's only a 0.05% chance of them being rotated. To rotate them the other way, once the length has been determined, I just move the x location of the book to the end point and negate the angle.

Stage 6 - Bookshelves

The task:

1. Create 2 simple bookshelves to place books on.

For one of the bookshelves I went back to blender and used the exact dimensions of an Ikea Kallax Cube:

I UV-unwrapped it and created material slots so I could just apply a simple wood material from the UE4 starter content.

For the other bookshelf, I placed a load of cubes in the editor, scaled/rotated them and then converted them to a Blueprint:

This isn't as perfect as creating the mesh in blender as the sides are warped but it's good enough and not that noticeable when playing in game.

Stage 7 - Bookshelf Blueprint

The task:

1. Create a bookshelf that when dragged into the editor has books randomly spawn on it.

I ended up doing this task in 40 minutes as I already had all the other blueprints. I simply created a few "spawn points" on the mesh and then called "Add Child Actor Component" in the construction script. These calls were behind random weighted bools so not all spawn points are always used.

And that's it! There are so many more things I want to do and feature creep is rearing it's ugly head but I set out to do specific things; I accomplished that and now it's time to go back to C++ land.

I really enjoyed this task; more so as I got used to blueprint. I remember doing beginner tutorials and wondering how on earth you were supposed to remember all the nodes. The truth it you don't; it's like normal programming only you don't know the language so you search for the appropriate node/google it until you get used to it. Blueprint is super fast for iterating through designs and I rather enjoyed not having to build the editor and open it every time I made a "code" change.

Future tasks do include though:

1. Allowing the blueprints to be cooked out to merged static meshes to reduce draw calls
2. Re-doing everything in C++/Blueprint (I do some heavy maths in blueprint and it hurts my soul)