Procedurally Generated Firearms

Demo Instructions:

• Right Click - Shoot
  
• P - Generate new PGF (Procedurally Generated Firearm)
  
• Drag Sliders - Adjust PGF values
  

Values:  Each value has a specific effect on how the projectile out of the firearm is shot. However, some of these values are specifically gameplay related (Impact Damage Value, for example, has no effect in our tech demo because we have nothing / no entities to damage). Some of the most impactful values in our demo would be initial speed value, spread angle value, or dropoff value, which directly changes how the projectiles are shot.

Development Notes:

Goal: We wanted to create a tool that generates procedural projectile-style firearms.

Design Process: We studied a variety of different shooters that have projectile-style weapons, and defined a set of criteria of weapons. Overwatch served as a useful touchstone, since each character has distinct mechanics for their weapon.

In Overwatch, we looked at what features firearms have that changes the way users interact with them. One comparison that we analyzed was the difference between characters Symmetra and Junkrat. Both fire projectiles which cause high damage on impact, but because of the difference in projectile speed (low for Symmetra and high for Junkrat) and gravity (none for Symmetra and high for Junkrat), the two heroes have very different play styles.

We factored this into the fundamental design of our system, which evolved to initially include the following firearm features.

Projectile Firearm Characteristics:
    - Bolt / Semi-automatic / Burst / Auto
    - Damage
        - Damage falloff
    - Range
    - Velocity
    - Rate of Fire
    - Reload
        - Ammo Capacity
        - Time of reload
    - Charge Time
    - Random Spread
    - Projectile Count
    - Area of Effect Damage on Impact
    - Bullet drop
    - Crowd control (Push Back)

Development and Implementation: We moved to try to create a system of procedural generation based on these criteria.

Our biggest challenge was that of definition: each of our defining features had to be orthogonal - that is, increasing / decreasing any one feature has no affect on any other feature.

Some features we realized were just a combination of others. For example, we took "range" out of our procedural generation because that was simply calculated by using initial velocity and the amount of gravity we are applying to our bullet. We also found overlap between our defined features. Initial speed, when increased, would negate the affect of drop off speed - the faster you move, the less time drop off has to affect your trajectory. So we had to redefine "drop off speed" as "drop off ratio" - the drop off is now a percentage of the initial speed. Thus, increasing the speed now has no affect on how quickly the bullet falls to the ground.

Scoring: In order to balance PGFs (Procedurally Generated Firearms), we had to know how "good" a value for a feature is. We calculate a score, we need to:
1) Provide a minimum and maximum value for each feature (tricky)
2) Define an ideal value for this feature (very tricky! To find the real ideal would take a lot of playtesting)

In the future, rather than provide a value and get a score, we provide a score and get a value. This way we can divide up "points" between each feature of the gun, and get some kind of balancing.

Next Steps: We are potentially interested in using this system to generate firearms for a shooter. Since we created a system that can create almost any type of gun with different characteristics, we can tweak the values to allow for any kind of gameplay. We are excited to see what the tool's consequences will be in terms of game design.

Source Code: Feel free to use any of the code we have written, or just take a look.
https://github.com/elliot-winch/procjam2018

Project by Elliot Winch (https://elliot-winch.github.io/portfoliowebsite.github.io/) and Carlos-Michael Rodriguez (https://www.carlos-michael.com). Thanks to Nina Demirjian (https://www.ninademirjian.com/) for help with our banner and playtesting.