[3P stealth-action] MicroWave

MicroWave is a 3rd person stealth-action game, which I developed during my lonely evenings when I worked on my diploma project in Research Centre “Juelich” (Germany). The main motivation of this project is to use it as a portfolio to get a job in the game development industry, since approximately one year ago I decided I want to create games rather to do science (for some people, who didn’t do science, it sounds weird). Recently I finished my university and achieved an engineer-physicist. Now I’m looking for a job, so if you know somebody (who knows somebody), who needs a C++ gameplay programmer - here am I, ready to go =D Below is the description of my project…

My project

In the game, the player uses MW-gun and blind corners to breach the guarding system and complete the level. Guards are MOTs (mounted guards) and PATs (patrolling guards). MOTs are mounted on walls and guard a given corner. PATs patrol a given path. Both guards have sensors and weapons. Once a stranger is seen or heard, they start recognition process, giving the player a chance to flee. If recognition completes, guard starts attacking the stranger, giving it a tiny chance to flee.

To disable a guard, the Burglar fires the MW-gun at them. MW-gun has two modes: normal and powerful. In normal mode it slowly consumes battery charge, resulting in weaker MW-radiation. Normal mode is used to interfere the sensor of a guard, which gives the player a chance to be unrecognised. In powerful mode, MW-gun fires a bunch of MW-radiation and completely brings down a guard, but in cost of higher charge loss. Once battery is down, there is a MW-station to charge up.

This is a non-commercial project, aimed to demonstrate my gameplay programming skills (I’m sorry for bad graphics). The majority of gameplay is implemented in C++, save AI logic and some Blueprint prototypes. You can access the source code on GitHub:

Check out the demo video:

What would you change or add to the game? Suggestions are welcome!


If you have any questions, I’m glad to help you!


And yes, I want to thank Epic Games for such a great engine, which made it possible to quickly prototype and build a game, and, of course, the wonderful community, which is always here to share experience!

Love your work mate. I love how you made the meter on his arm that works with the MW gun. However I’ve got a few suggestions. However keep in mind I’m not a programmer and maybe talking way overboard but personally would love to see the following if it were a programming demo reel:

  1. Health bar that reduces instead of numbers for health.
  2. Blood on the screen or red damage HUD whenever he takes damage.
  3. Probably a line of sight/ spotlight-esque detection system? If the player slowly walks behind a guard he cannot be detected. But if the enemy runs then the guard detects by hearing footsteps.
  4. Once a guard sees us and if we use the normal mode it stuns the guard for a second instead of rendering us unrecognizable as long as we keep shooting. BUT when the guard comes out of the stun he breaks his patrol path and goes to the “last seen position” of us to search for us.
  5. A minimap to see the guards around us and strategically move.
  6. If minimap makes the game too easy, then maybe thermal vision that helps us see through walls and can help us out? Thermal vision can also have a limit to use that goes down in 5 seconds and it takes 10 seconds for it to regenerate again? Maybe a bar on the side to represent this.

Probably I said things that were way too hard and I’m sorry if they are because I’m no programmer, but I do know that the things I said are achievable by blueprints so I’m hoping that they are by C++ too. I hope you like the suggestions but overall I must say I love the work you’ve done and wish you success with your job hunt for being a gameplay programmer.

Cheers mate!

Hi, VeerWolf!

Thank you for finding a time to write such a nice review, I appreciate that! Some of your points match those of other guys, who also commented my work. For example, blood on the screen when the avatar takes damage. People from different background comment my game and give me new ideas and it’s great!

Each of your point deserves attention, so I will go through all of them.

  1. Numbers for health status is the result of my laziness to struggle with everything related to graphics. In stealth game, the player must have a little chance to survive once being spotted, so 100-scale status doesn’t make much sense (it do in action games, when one hit doesn’t cause much damage). I think a bar with 4-5 divisions would be better, but this is not a critical issue at the moment.
  2. Blood on the screen would be very useful!
  3. Actually, there are two view zones: direct and peripheral. The direct view zone is visualized by a lightcone, and while the avatar is out of this lightcone, a guard can’t recognize him (but the guard is aware of him). The peripheral view zone is not visualized, but it is defined by an angle and usually is 60 degrees. The AI system of the guards allow to “hear” the enemy if the enemy is close and noisy enough. If we render the second lightcone for the peripheral view zone, wouldn’t it be confusing?
  4. This is the point where I spent a lot of time thinking how it would be better… The normal mode is used to increase player’s chances to flee out of danger by cost of little charge loss, while accumulative shot (which consumes significant amount of charge) is supposed to completely destroy a guard. When you shoot in normal mode, you interfere the sensor component of a guard and it can’t recognize you, but you have to keep shooting, otherwise it will start to recognize you. So we need to find a way to let the player know that the guard at aim is interfered (in my case the guards “eye” starts to twitch in a crazy way).
  5. This would definitely make the game too easy.
  6. This is better, player always has to pay for cheating! Thermal vision is cool but I always try to reuse the gameplay mechanics I have (Valve’s Portal is a great example - entire game with a single gun!). What about using the MW-gun as a mine detector? You shoot at walls and if there is a guard behind the wall, you hear beeping. It reuses existing mechanics and player pays for cheating by cost of battery charge loss.

Many things which are presented in this games are the result of optimisation of development time and the lack of some skills (like art). For example, there aren’t human guards because I doesn’t have such modelling & animating skills, but I’m able to create a simple mesh like a plane or a camera. And from here comes the MW-gun.

Again, thank you for comments, mate! :slight_smile:

P. S. What is your specialization, by the way?

Looks pretty cool dude! I have a suggestion though. I find it a little difficult to look around corners that are to the left of the player when the camera is to the right of the player. :smiley: You should setup a toggle to switch the shoulder the camera is looking over. Create a variable that determines how far the camera moves to the side of the player (Y axis) and use FMath::VInterpTo:


UPROPERTY(EditAnywhere, Category = "Camera")
float CameraSideY;

void ToggleShoulder();

float cameraY;


// Assign input to this method
void GameCharacter::ToggleShoulder()
     cameraY = (Camera->RelativeLocation.Y == CameraSideY) ? -CameraSideY : CameraSideY;

void GameCharacter::Tick(float DeltaSeconds)
    Camera->SetRelativeLocation(FMath::VInterpTo(Camera->RelativeLocation, FVector(Camera->RelativeLocation.X, cameraY, Camera->RelativeLocation.Z), DeltaSeconds, 10));

That should be it. Tell me what you think. Keep up the good work! :slight_smile:

Hi, KoldKam!

Thank you for your notice, looking over the left shoulder from a corner can became really annoying. Toggling Y-offset of the camera is a quick-and-dirty solution, but should the player deal with the imperfection of the game? The solution should be automatic: when the player presses against a wall, the camera should toggle the Y-offset automatically, depending on whether a corner is right or left. It could be done using raycasts and simple geometry.

If you browse the code, you can see that my camera is attached to USpringArmComponent. It allows to automatically adjust the arm length depending on where the arm intersects geometry. But once you press against a wall and try to look from the wall, you face a problem - camera looks inside character’s mesh. I thought about a key that toggles 1P and 3P view, but for the same reason as above, I decided to do it automatically: when the arm’s length becames too short, the camera attaches to another spring arm, which imitates 1P view. Once 3P spring arm is long enough, the camera goes back.

I noticed a little danger in your code. Comparing two floats with operator == is potential bug, because the variable Camera->RelativeLocation.Y by any reason could became slightly different from CameraSideY and you will never meet the condition. Use FMath::IsNearlyEqual() instead (if you didn’t know about that, of course…).

Thank you again and keep reviewing :wink:

Hey, sorry about that code! Thanks for the correction. :slight_smile: I was in a rush and typing it on my tablet, haha. I actually had a third person project in which it switched automatically based on the player’s distance kind of the same way. It seemed to work pretty well. :smiley: Anyways, keep up the good work and I wish you luck on your job hunt! :slight_smile:

Big GitHub repository update!

Big GitHub repository update!

Today I uploaded entire project into the GitHub repository. Now you can fetch it, compile and run! It consists all the necessary Blueprints and Behaviour Trees, as well as the map and other stuff.

Feel free to use and modify it for your needs! And don’t forget to comment and criticise!

I think a few screenshots wouldn’t hurt:

Hi guys!

Good news. I have developed a prototype of the cover taking system for my game MicroWave. The main features of this system are nearest cover point search & take, automatic crouching depending on the height of the cover, pressing against walls, automatic peeking out of corners when near to corners.

When I developed this system I kept in mind an idea to minimize routine work, like defining cover paths (walls) manually. I used raycasting to define safe height for the avatar’s head and to connect two corners with a cover path (red spheres on the video). To help the engine to build the cover path, you have to drop corner denotation actors in the level, where actually geometrical corners are. Additionally, you have to drop somewhere CornersPair actor to connect two corners into a cover taking path.

My next steps are to create an algorithm which builds cover paths without of need of CornersPair actors and make the avatar to press its back against the wall. At the moment, all algorithms are in Blueprints, but they will be converted into C++ as soon as the prototype gets polished.

Enjoy the video

The last, but not the least, check out the project on GitHub. Feel free to use and modify it.