Good gameplay draws the attention of every player. Why do players keep playing? Because it’s engaging. Every flashy action that makes the player want more is engaging. My focus has always been making engaging gameplay:

• How does the player take their first steps into an unknown world?
• Interact with the UI and HUD?
• Defeat their first enemy?
• Parkour off of walls and ceilings?
• Experience their first death at the hands of the enemy?
• Traverse large landscapes?
• Defeat the final boss in epic fashion they will remember forever?

The player cares about every instance of gameplay. Everything the player does matters. Everything the player interacts with matters. My focus is making every part of that “everything” feel engaging.

How do we make gameplay engaging? Iteration.

Iteration is the key that unlocks an unforgettable player experience.

How? Let me show you using a mechanic I have recently worked on.

CASE STUDY: Goosthetic Smart Pistol

The problem:

What are we trying to solve? What does the player require in your game? For us, our problem is:

How do we dynamically target moving enemies in a large 3D environment while moving at breakneck speeds through the space, and then automatically fire homing projectiles at prioritized targets?

Requirements of solution:

It is important to note the intended design of the mechanic and design pillars of the game must be acknowledged throughout the entire development process of the mechanic. These can change through the course of development and should continue to be the goal. Our requirements for this mechanic:

• Auto targeting weapon
• Player should hold down the input key to begin targeting enemies
• Enemies should be prioritized in order of distance from the center of the reticle
• Bullets will fire once released
• Bullets are homing projectiles to almost guarantee the kill
• Reticle should scale over time showing which enemies can be targeted
• Possible targets should have a visual indicator if they are going to be targeted
• SFX should play when the action begins, a new target is found, and when the action ends

Early solutions:

Every mechanic, in the beginning, has a phase of janky and unworthy solutions to the problem. Every iteration matters even if they don’t meet any of the requirements. Every tried solution leads to the ultimate solution. My first steps in this solution were:

RESULT: POOR.

Not dynamic, gave very little feedback to the player, and was not accurate to the intended design (didn’t accurately target enemies in the field-of-view because a sphere is not the same as a cone).

These early solutions are getting somewhere. We haven’t completely failed. We have successfully targeted enemies and fired at them enough for them to die. Let’s take what we’ve learned and continue iterating.

Nearly good enough solution:

At this point, we are beginning to have a workable solution. Our goal is to have something that can be reasonably tested against our intended design to see what needs to happen next. I attempted the following:

Created a custom cone-trace function which followed the following process:

RESULT: WORKABLE BUT CRASH-PRONE.

Still not dynamic (everything regarding targeting is done at once and not per frame), gave some additional feedback (still not enough), and was mostly accurate to the design, but was computationally expensive (unable to run calculations every frame smoothly), redundant (lots of overlap between the sphere traces), and crash-prone (if calculations were done every frame).

We learned a lot here. We have successfully targeted enemies in a cone originating from the player. The enemies are prioritized and killed with the correct amount of bullets. However, the only feedback we are giving is just the reticle expanding to show possible targets and SFX when the player starts and stops the action. We still need to know when a new target is found.

Best solution:

This next iteration can take our mechanic from decent to great. This can make it engaging. We have almost achieved the intended design. All we are missing is crucial feedback. How do we take a technically working solution and make it give the feedback we need? We refactor. Here’s what I did:

Utilized my knowledge of graphics rendering to take advantage of screen space coordinates by implementing the following process:

RESULT: ENGAGING AND ROBUST.

This solution was massively more performant and robust. It was also more exact by utilizing the screen space to use the player’s field-of-view. It is being calculated on a per-frame basis which allows for feedback regarding each individual target.  And it was far more immersive for the player, as VFX and SFX could now be fluidly experienced upon every frame, without incurring any crash risk.

Now we have engaging gameplay. It feels good to see what is being targeted and know what is going to happen. I only know this is engaging because of playtesting. Players keep wanting to use the smart pistol. Over and over again. With that said, can it be improved? Yes.

Even Better Solution:

The previous solution is fantastic. It meets the design and is engaging to the player. But it can be more engaging. This is where elements of user experience design come in and change the whole game. We have something that feels good, but how can we make it feel great? The answer heavily relies on the design pillars. Our pillars aligned with my next iteration:

RESULT: I CAN’T STOP PLAYING.

Now we have combined an already engaging and robust solution with an experience that has no equivalent. Utilizing features that don’t inherently affect gameplay to enhance gameplay is incredibly powerful.

Conclusion

Every element of a game matters. It matters how a button is pressed, how a card is flipped, how an attack is carried out, and how damage is taken. Whatever it is, it matters. The player cares about what they interact with. As developers, it is our duty to make it the best experience they’ve had. And this can’t be done immediately. It takes time. It takes iterations. Iterations are how we make engaging games.