top of page

Acerca de

Dragon Hat Debug.png

Weird Hat Fight
Combat Design & Systems Design

About Weird Hat Fight

Weird Hat Fight is a party game where you fight your friends to the death using magic hats.
The game was developed for the final year project in the University of Utah's EAE Masters Program over the course of approximately 8 months.
While working on the game, I served as the Project Lead, Lead Engineer, and Lead Designer.

General Combat Design

I joined Weird Hat Fight after the prototyping stage had been completed. From the prototype, it was clear the game had promise, but there was clearly something missing. The initial format of combat in the game was that each player had a single life, and 100 HP. Hats (which each had an ability tied to them) could be picked up and discarded at will, and each hat primarily did damage (with no other significant effects). Once a player's HP hit zero they were eliminated, with the last player standing being the winner.

When I joined the team and began operating as the Lead Designer, the first thing I did was playtest the game extensively, and play it in various different ways. I then identified the areas where I thought the combat had the most problems:

  1. Hats had nearly no practical differentiating factors.

  2. The combat felt unresponsive.

  3. It was extremely easy to continuously damage a player without interruption until they were dead.

  4. Players would typically find their favorite hat and keep it forever.

  5. When two players attempted to pick up the same hat, the one who didn't get the hat had a nearly insurmountable disadvantage.

  6. It was extremely difficult to keep track of health when there were more than two players in the game.

After identifying these problems, I set about trying to fix them. The first thing I did was to try and address problem #1, as it was the most significant problem. After looking at the systems available as a whole, it became quite apparent that the problem was that hats could fundamentally only ever do one thing: Do Damage. They could change the amount of damage, how easy it was to hit enemies with the ability, and the cooldown, but fundamentally there weren't enough unique ways to do damage in the games system. That left me with two options. Firstly, I could focus on attempting to differentiate the various ways to do damage. When I looked into this, it became clear that doing this would probably require shifting the target audience, as the options available would require more skillful expression to interact with than a party game generally expects. The clearest example of this would be fighting games, which often include dodges that put an emphasis on timing. In fighting games, attacks vary their timings and some attacks may take longer to execute to allow the enemy an opportunity to dodge and counter-attack, while others might be shorter to prevent this from happening. However interactions like this require significantly more skill expression from the players than I felt fit our target audience.

The second option was to add another output to the hats other than damage. This was the route I ended up going, as the goal was to create a party game, which necessitates a low skill floor. This new output had to still be targeted towards defeating your opponents, which significantly limited the options for what it could be. Given that the game already included a mechanic where falling of the stage resulted in instant elimination, I leaned into this and made knockbacks the other output besides damage.

Introducing knockbacks to the game and attaching them to all attacks solved a lot of issues. It firstly solved problem #1, as it drastically increased the problem space. Not only could I vary both the damage and the knockback strength of attacks, I could also vary the knockback direction. Additionally, adding knockback solved problem #2 (since there was an immediate visual reaction to getting hit) and solved problem #3 (since attacks could be made to knock enemies out of range of a followup).

Despite this, adding knockbacks introduced a new issue. You could defeat an opponent by lowering their health to 0 or knocking them off the edge, but these two mechanics felt unrelated. If you knocked an opponent off the edge, you didn't care if they were at 1 HP or 100 HP. Likewise, if you wanted to reduce a player to 0 HP you didn't care about the knockback mechanics at all. To solve this, I took inspiration from the Smash Bros series and replaced the health counter (which counted down) to a damage counter (which counted up). I removed the death condition upon taking too much damage, and made knockback force stronger the more damage you had. Doing this also had the side effect of solving problem #6, as now your health was significantly less important (so losing track of it occasionally was acceptable). This resulted in attacks having the following balancing levers for the problem space:

  • Damage Per Hit

  • Base Knockback (Amount of knockback applied regardless of the damage level of the player hit).

  • Growth Knockback (Amount of knockback applied per 100 damage already on the player hit).

  • Launch Angle (The angle the player is knocked back in).

  • Attack Startup Time (How long it takes for the attack to actually generate a hitbox after the player presses the button).

  • Attack Duration

  • Hitbox Shape

  • Attack Range

  • Attack Cooldown

The next issue was that players would pick up their favored hat then keep it forever. While playtesting, I discovered the game was the most fun if players were required to swap hats often. While the intention of the original designer had been that the hats should be good at different things, and thus there should be reason to swap, I found that it was difficult, if not impossible, to design for that. The major reason players were never incentivized to swap hats for one that was better in a given situation was that the situation was always the same. There weren't enough variables changing in the game environment to make some hats better or worse. Rather than make the situation the players were in change wildly over the course of a match (which I judged would make level design significantly more time consuming, no matter what implementation method I chose), I decided to instead force the players to change hats. To do this, I added either a maximum number of uses, or a maximum use time (for hats with a continuous effect) to all hats. After being used too often, the hat would expire and the player would require a new one. This solved this problem well, and in testing I found that players enjoyed the game the most when they were required to constantly swap hats (receiving only a single use out of most hats).

The last problem remaining was problem #5, where if a player was stuck without a hat when their opponents had one, they were nearly guaranteed to lose. The solution to this was fairly easy, I added a attack that players could use when not wearing a hat. This attack was weaker than any hat, but lessened the gap between players with hats and those without.

After all of these changes, I dived back into playtesting to identify new pain points. I was pleasantly surprised to find very little. There were two major issues I identified:

  • More experienced players became frustrated at their inability to do anything when knocked off the edge.

  • The games ended too quickly.

To fix the issue where the games ended too quickly, I first tried decreasing knockback scaling in order to require players to apply higher damage amounts before knockback began to become dangerous. While this had the intended effect of prolonging games, it made them feel like a slog. I reverted this change and instead chose to give each player a number of lives, only eliminating them when they ran out of lives. This felt much better, and solved the problem.

The other issue was trickier. It was clear that it was frustrating to be knocked off the edge with no possibility of recovering, but most solutions to this problem caused other problems. If players were given the ability to easily recover (for example, by having a single air jump after being knocked back) then it became extremely hard to actually defeat another player and became frustrating to play for the opposite reason. After several failed attempts, I came up with an idea: What if you could recover, but it cost you something? Once I had that idea, I quickly found a solution that was satisfactory. By dropping a worn hat while in the air, the player performs a strong air jump, giving them a chance to return to the level. This works fantastically, due to the following attributes:

  • It emphasizes periods of strength and weakness (as not having a hat means you lack the ability to recover).

  • Recovering still has a cost, so it feels better to the attacking player.

  • It is less accessible to new players. This turns out to be a boon in disguise, as it creates the feeling that there are  techniques to learn and there is room to improve (all while not actually providing too much of a benefit to players able to execute it, as they are still at high damage and likely to just be knocked off the edge again).

After these changes, I performed more playtesting and found no more major pain points. This combat design is what is used in the final version of Weird Hat Fight.

Ability Design - The Bunny Hat

In Weird Hat Fight, each ability is contained within a Hat, which is worn by the player to gain access to said ability. The hat that I had the biggest contribution to was the Bunny Hat. When I joined the team after the initial prototyping phase and became Lead Designer, I overhauled the combat system to make it more fluid and fun (see General Combat Design). While doing so, I needed some hats in order to test the combat system. While there were a few hats implemented in the initial prototype, they were inaccessible due to the team's decision to switch engines after the prototype's completion. As such, I had the option to recreate hats from the prototype, but also to make new hats. In particular, we had a couple of art assets created for the prototype that were unused. Among these was the bunny hat art, which I decided to choose as one of the initial hats.

I first considered what sort of ability a Bunny Hat should have. I chose a ground-pound style ability, wherein the player jumps in the air then slams downward, hitting enemies under and around them. I also wanted to exercise the character controller (which I was designing in concert), so I decided to passively make the player jump higher while using the Bunny Hat.

In my initial design, I imagined the hat as having a two input sequence to use. Firstly the player would need to jump into the air (as a ground pound when touching the ground shouldn't do anything) then they would activate the ability button to slam to the ground. I implemented this design and tweaked it until it felt good to play, then set out to playtest it. Much to my dismay while players enjoyed the ability, they were confused how to use it. Going back to the drawing board, I tweaked the functionality of the ability. In the new design two different actions were performed depending on whether the player was touching the ground or not. If the player is touching the ground when the ability button is pressed, the player immediately jumps then performs the ground pound at the zenith of their jump. If the player is in the air when the button is pressed, then they immediately perform the ground pound. I went back to playtesting and was happy to find that the confusion on how to use the ability was completely gone.

I was pleased with these results and shelved development on the hat for a while until there were more hats in the game and I could properly tune and balance the hats. Once we had our first set of hats, I began tuning the bunny hat. While doing so, I noticed a discrepancy. In order to feel usable, the hat needed to hit players in a fairly wide area around it. However when balanced for that large area, the hat's knockback felt weak if you directly hit another player's head. I considered increasing the knockback as the player got closer to the center, but then realized that unique behaviour like that would be difficult to balance for. Instead, I decided to add a secondary hitbox to the attack. This secondary "sweetspot" hitbox appears slightly before the larger hitbox, and hits the area directly below the player using the ability. If it hits a player, it applies a significantly stronger knockback to them. This system felt satisfying, and thus the bunny hat was finished.

Hat Systems Design

Once I finalized the combat system Weird Hat Fight would be using (see General Combat Design) I needed a way to balance hats around it. In particular, I needed a way to quantify how dangerous a certain amount of knockback was. This is difficult because unlike pure damage, it's contextual. A low knockback ability can kill a player on the edge of the stage, but will never threaten a player in the middle of the stage. As such I resolved to make a spreadsheet calculator that could model the danger presented by an ability.

The first thing that I needed to do was discover how much force it took to knock a character off the stage at different angles. I chose to model this by creating the simplest possible stage (a circular platform, scaled to a comfortable size for 4 players to fight on) and setting up killzones on it that felt reasonable in testing. I then created a script which would launch the player at a specific angle with a specific force when when I pressed a button. I then found the exact threshold where the player would die when the angle was horizontal (this was the force needed to throw the player off the edge), vertical (this was the force needed to throw the player into the ceiling killzone) and 45 degrees (this was the force needed to either throw the player off the edge or hit the vertical killzone when launched at 45 degrees). I found and recorded these numbers from the center of the platform, and from the very edge of the platform (wherein the player would need to cross over the entirety of the platform to reach the edge). While recording these numbers, I discovered that the player regained control part-way through being launched, and could influence their trajectory somewhat. I thus recorded a second set of numbers for when the player was attempting to return to the platform. These I labeled "Force Needed to Probably Kill" (for the force needed when the player doesn't resist the knockback) and "Force Needed to Definitely Kill" (for the force needed when the player does resist the knockback). In the spreadsheet calculator, I use these numbers to perform a simple linear interpolation between horizontal to the 45 degree mark or from the 45 degree mark to vertical in order to represent any angle. This isn't entirely accurate, but is close enough for the purpose of getting a sense of how dangerous the attack is.

I now had a method to determine the force needed to probably kill a player, or definitely kill a player (at both the center of the platform or at the edge if they are launched over the entire platform). I next needed a way to relate this to each attack, so I could display how dangerous the attack is to the designer. I considered various different ways to represent this, and decided that the most useful metric would be how much damage a player must take before a given attack will probably kill that player (if they are standing in the center of the stage). I chose this metric because the paradigm of attempting to knock other players off the edge of the stage is an all or nothing approach. As a player, it doesn't matter how close you get to defeating other players, only if they're actually defeated. Knocking a player close to the edge of the stage doesn't make them significantly more likely to die to future attacks. Instead damaging them is the primary way to make them more likely to die to future attacks. As such, the pieces of information most useful to a designer are the damage dealt by the attack (which is already provided by the designer) and the damage threshold at which the attack will likely begin scoring kills.

Calculating how much damage is needed to probably kill a player is relatively easy once we know the force needed to kill a player at a given angle. The equation of force generated is baseKnockback + knockbackGrowth * ((damageOfAttack/100) + (totalDamage/100)) where damageOfAttack is the damage that will be dealt by this attack and totalDamage is the damage a player has had applied to them before this attack hit. As such, the equation for how much damage a player needs to have applied to them before an attack will likely kill them is totalDamage = ((forceNeededToKill - baseKnockback) / knockbackGrowth - (damageOfAttack/100)) * 100.

In addition to displaying this, I also display a reminded to the designer of how much total damage an attack will apply (this is relevant for multi-hit attacks), the damage needed to probably kill from anywhere (rather than just from the center of the stage), and the force that would be applied at 50, 100, 200, and 999 damage. While the two most useful metrics are the damage applied and the estimated damage needed to kill from the center of the stage, the other metrics do have limited use in showing the designers roughly how the knockback scales as damage is applied.

A copy of the spreadsheet is available below along with a brief description of each page:

  • Readme: The legend for what different cell colors mean.

    • This sheet is locked and not interactable.

  • Hats: This is the primary spreadsheet designers should interact with.

    • This sheet is interactable.

  • More Hat Info: Contains additional information that is calculated relating to how dangerous a hat is. Mostly made available to make debugging the spreadsheet calculator easier.

    • This sheet is locked and not interactable.

  • Reference: Contains information recorded via observation that is used in calculations elsewhere in the sheet. Data here should be changed to coincide with changes to stages.

    • This sheet is locked and not interactable.

  • Documentation: Contains information not used in any calculations in the sheet, but that should be included so that the sheet better explains the design of the system without supplementary documents.

    • This sheet is locked and not interactable.

Note:
The linked spreadsheet calculator is interactive. If someone else is using the spreadsheet, please wait your turn.

Where possible, try and leave the spreadsheet how you found it.

If you believe that the spreadsheet has been damaged or defaced (e.g. deleted spreadsheet comments) please contact me at: JoshuaBrandonButner@gmail.com.


Thank you!

General Combat Design
Ability Design - The Bunny Hat
Hat Systems Design

© 2022 — Joshua Butner.

bottom of page