Dev Blog

HFFWS Thesis: Starting Ramp Puzzle Generation

March 5, 2020

Ramp Puzzle Scenario Generation

Thesis Project

Notes

I have added the basic foundation for creating ramp scenarios in my HFFWS generation system for my thesis project. This starts with simply making very standard full ramp objects with a corresponding obstacle object.

The ramp objects are the most straight forward ramp shape, being a flat angular shape. They are scaled randomly given a range of parameters for all three dimensions. These are generated first, and then the obstacle is generated with data passed from the creation of the ramp. Right now it just accepts the height data from the generated ramp and uses it as the new maxHeight option for the obstacle. The idea is that this will keep the obstacle from ever being out of reach of the ramp (but this will actually require the tweaking of a few other parameters as well, such as positioning).

Sample Image of 5 Generated Ramp Scenarios

Human: Fall Flat Level Concept/Skill Breakdown – Medieval

February 27, 2020

HFF Level Concept/Skill Breakdown

Level: Medieval

Playthrough Sources Referenced

Human Fall Flat (No Commentary) (16/09/2017)

Video #1

By: SpeedyAvatar


Human Fall Flat – Full Playthrough w/ summit1g

Video #2

By: summit1g


Title: Automatic Game Progression Design through Analysis of Solution Features
Source:

E. Butler, E. Andersen, A. M. Smith, S. Gulwani, and Z. Popović, “Automatic Game Progression Design through Analysis of Solution Features,” 2015, pp. 2407–2416, doi: 10.1145/2702123.2702330.

Overview

I am looking into existing HFF levels to analyze the various small puzzle scenarios present in an attempt to breakdown what skills and/or concepts the player needs to understand or be able to act upon in order to complete them. The approach on how these are broken down was inspired by the the way procedural traces and n-grams are used in the above source by Butler et al. It is hoped that this approach to breaking down various puzzle scenarios in HFF will help with the automatic generation of such scenarios. I have also included an object list for each scenario to keep track of how many objects are needed for simple puzzle scenarios.

This breakdown goes throw the Medieval level of the base Human: Fall Flat game. I split up the individual puzzle scenarios the player encounters throughout the level in the steps required for a single solution avenue for completing the puzzle. Each of these steps is them given some simple skill or concepts necessary to understand to perform each step.

Medieval Level Breakdown

Scenario 1

    Intro: Lock Smashing

  1. Picks up rock (Grab)
  2. Breaks lock with rock (Breakable Object)(Apply Force)
  3. Opens door (Grab)(Pull)(Open door)
Object list:

Rock, Door, Lock


Scenario 2

    Cross Gap to Door

  1. Grabs long bar (Grab)
  2. Places bar over gap to act as bridge (Create platform)
  3. Walks across bar to door
Object list:

Long Bar, Stairs, Platform, Door


Scenario 3

    Catapult to Break Walls

  1. Move catapult into position (Push)(Pull)
  2. Wind catapult to loading position (Push)(Pull)(Grab)(Interact)
  3. Lift rock onto catapult (Pickup object)
  4. Press catapult lever to shoot rock (Push)(Interact)
  5. Rock hits wall to break it open: Gravity for aiming (Apply force)(Force = mass * acceleration)(Gravity)(Breakable Object)
Object list:

Catapult, Rock(s), Wall


Scenario 4

    Inside Castle: Rickshaw Platform

  1. Grab rickshaw handles (Grab)
  2. Lift rickshaw up by handles : Helps wheels to roll (Lift object)(Friction)
  3. Move rickshaw with rock on it into place as platform (Create platform)
  4. Lift self onto rock (Lift self)
  5. Jump onto higher area (Jump)
Object list:

Rickshaw, Large Rock (on rickshaw), Platform


Scenario 5

    Swinging Between Lanterns

  1. Lift bar on door to open it (Lift object)
  2. Bring in rickshaw from previous section (Resource management)(Memory)
  3. Move rickshaw with rock on it into place as platform (Create platform)
  4. Lift self onto rock (Lift self)
  5. Jump onto higher area (Jump)
  6. Jump onto lantern to swing (Jump)(Grab)(Hold)
  7. Swing on lantern (Momentum)
  8. Jump from lantern to platform : Falling to lower platform (Momentum)(Gravity)
Object list:

Rickshaw, Large Rock (on rickshaw), Platform (Many), Lantern(s) (Many)


Scenario 6

    Move Very Heavy Rickshaw

  1. Move (heavier) rickshaw with rock on it into place as platform (Create platform)
  2. Jump and lift self onto nearby platform several times (Jump)(Lift self)
  3. Go across platform created by rickshaw moved in place
Object list:

Large Rickshaw, Rock (Very heavy), Small Platforms (Many), Bridge (with gap)


Scenario 7

    Swing Across Gap with Hook

  1. Grab large hook (Pickup object)(Grab)
  2. Hook hook onto protruding bar to swing self across gap (Momentum)(Gravity)(Hold)
Object list:

Large Hook, Protruding Bar, Platform


Scenario 8

    Rotate Pulley-Like Wheel to Lift Board as Ramp

  1. Pickup Large Hook (Pickup object)
  2. Use hook to pull down above large wooden board (Gravity)(Reach)(Pull)
  3. Pull large wooden board so half is on roped stone (Pull)
  4. Rotate nearby wheel connected to rope to lift stone, raising the large wooden board to create a ramp platform (Pulley)(Create platform)
Object list:

Large Hook, Large Wooden Board, Platform, Wheel Pulley Setup (Large Wheel connected to Rope which is connected to Large Stone), Terrain Bump


Scenario 9

    Push Barrel Down Ramp and Climb Many Platforms

  1. Open Door (Pull)
  2. Go up stairs
  3. Open Door (Pull)
  4. Roll barrel down ramp to get to other side (Pull)(Push)(Gravity)(Ramp)(Roll)
  5. Move barrel in position to reach next platform (Create Platform)(Pull)(Push)
  6. Jump onto barrel and next higher platforms (Jump)(Lift self)
  7. Jump up onto several higher platforms (Jump)(Lift self)
  8. Turn wheel to open gate (Interact)(Grab)(Open door)
Object list:

Barrel, Ramp, High Platform, Platforms (Many), Gate (with attached wheel opening device)


Scenario 10

    Free Lantern to Swing From

  1. Grab Large Hook (Pickup object)
  2. Use hook to free stuck lantern with chain (Reach)(Interact)
  3. Swing on lantern to next platform (Jump)(Hold)(Momentum)(Gravity)
  4. Grab platform and lift self up (Lift self)(Hold)(Grab)
Object list:

Large Hook, Lantern (w/chain), Platforms (Two)


Scenario 11

    Launch Self with Windmill

  1. Grab onto windmill (Grab)(Hold)
  2. Let go of windmill to launch self to next area (Momentum)(Gravity)
Object list:

Windmill, Platform


Scenario 12

    Build Ramp with Board, Anvil, and Cylinder

  1. Remove heavy anvil from board to free board (Push)(Pull)(Reduce Mass)
  2. Move anvil, board, and cylinder in front of open area of higher platform
  3. (Push)(Pull)
  4. Place board over cylinder so cylinder acts as fulcrum of ramp
  5. (Ramp)(Push)(Pull)(Create platform)
  6. Place anvil at far end of board to keep it pinned to the ground (Increase mass)(Ramp)(Cantilever)
  7. Walk up created ramp and jump and lift self to next area (Jump)(Lift self)
Object list:

Board, Anvil, Cylinder, High Platform


Scenario 13

    Build Ramp to Get Tethered Bucket into Hole

  1. Remove board from covering hole in ground (Pull)
  2. Move board to tree to use as ramp (Ramp)(Pull)
  3. Go up ramp to reach higher platforms (Jump)(Lift self)
  4. Free tethered bucket from high platform (Push)
Object list:

Bucket (connected to rope connected to tree), Tree, Boards (x2 on hole), Platforms (x2)


Scenario 14

    Loose Rock Pillar Cave Platforming

  1. Jump onto loose rock pillar to fall onto next platform (Momentum)(Jump)(Breakable Object)
  2. Walk across next rock platform
  3. Jump to rock platform which breaks and falls to next platform (Jump)(Hold)(Breakable Object)(Momentum)
  4. Lift self onto next rock platform (Lift self)
  5. Jump to next loose rock pillar to fall into next area (Momentum)(Jump)(Breakable Object)
Object list:

Loose Rock Pillars (Many), Platforms (Many)


Scenario 15

    Launch Self to Castle Gate with Catapult

  1. Move catapult into position (Push)(Pull)
  2. Wind catapult to loading position (Push)(Pull)(Grab)(Interact)
  3. Load self into catapult
  4. Press catapult lever to shoot self (Push)(Interact)
  5. Hold onto draw bridge, which pulls it down (Hold)(Lever)(Torque)
  6. Lift long loose piece of bridge out (Pull)(Pickup object)
  7. Place long piece into opening in gate to create ramp (Ramp)
Object list:

Catapult, Draw Bridge


Using LM-GM Analysis on Human: Fall Flat for Thesis (Condensed Lists)

February 5, 2020

HFF LM-GM Analysis

Thesis Project

Title: Mapping learning and game mechanics for serious games analysis
Source:

S. Arnab et al., “Mapping learning and game mechanics for serious games analysis: Mapping learning and game mechanics,” British Journal of Educational Technology, vol. 46, no. 2, pp. 391–411, Mar. 2015, doi: 10.1111/bjet.12113.

List of Game Mechanics

The following is the list of game mechanics I observed in Human: Fall Flat according to the source above (with noting for those that are major factors, and those that are only really present in multiplayer):

  • Behavioral Momentum
  • Cooperation (*multiplayer only)
  • Collaboration (*multiplayer only)
  • Cascading Information (*multiplayer only)
  • Resource Management (Major factor)
  • Strategy/Planning (Major factor)
  • Infinite Gameplay (offered by game somewhat, but major focus of developed system)
  • Levels (Major factor)
  • Pavlovian Interactions
  • Feedback (major factor)
  • Movement
  • Design/Editing
  • Simulate/Response (Major factor)
  • Realism
  • Tutorial
  • Urgent Optimism

List of Learning Mechanics

The following is the list of learning mechanics I observed in Human: Fall Flat according to the source above (with noting for those that are major factors, and those that are only really present in multiplayer):

  • Instructional
  • Guidance
  • Action/Task (Major factor)
  • Observation (Major factor)
  • Feedback (Major factor)
  • Identify (Major factor)
  • Explore
  • Discover
  • Plan (Major factor)
  • Objectify (Major factor)
  • Experimentation (Major factor)
  • Hypothesis (Major factor)
  • Repetition (Major factor; system focus)
  • Analyze
  • Simulation (Major factor)
  • Ownership
  • Motivation (Major factor)
  • Incentive

Summary

These are just the condensed lists of mechanics I observed within HFF by applying those found in the source above. I will put up a post with my more in-depth analysis of how I believe each of these apply in HFF to support why I chose them.

I created this list to better understand what HFF provides as a possible learning tool. This also helped link the game mechanics with the learning mechanics to get a better idea of which parts of the game to focus on generating with our system to enhance the learning opportunities.

What Are Neural Networks? – Basics Videos

February 17, 2020

Neural Networks

Youtube Videos on the Basics

But what is a Neural Network? | Deep learning, chapter 1

Information #1 – Link

By: 3Blue1Brown


Neural Network Architectures

Information #2 – Link

By: Steve Brunton


Notes

I am following up on my original research into working with neural networks and machine learning. I started looking into the programming more before really looking into the full background of it, so I am going back to make sure I have a better understanding of the theory and concepts behind neural networks and machine learning. These sources I found seemed to be useful lectures to get a hold of the basic foundations for the concepts behind such ideas.

Basics of System.Random in C#

February 14, 2020

System.Random Methods

C# and Unity

Random Class (from Microsoft)

Information – Link

By: Microsoft


General Methods Looked Into

Random.Next

This selects a random integer either between 0 and maximum value, or between two different designated values.

Random.NextDouble

This generates a random floating point value between 0.0 and 1.0. This is the main one I will be looking to use since I have a lot of parameters where floating point values make sense, however since it only returns values between 0.0 and 1.0 specifically, I will have to just use it as a random multiplication factor.

Random.NextByte

This requires an input of an array of bytes. It will then fill that array with random byte values.

Why I am Investigating

My thesis project uses a lot of random values with its focus on varied procedural content generation, but I want to control the randomness a bit more with the implementation of a seeding system. A tutorial I did a while back on cellular automata uses a very basic seeding system for its randomization that I was looking to copy. It centers around this line where seed is just a string variable that can be set in the editor:
System.Random psuedoRandom = new System.Random(seed.GetHashCode());

As long as the seed string is the same and a value is randomly selected using this Random variable psuedoRandom, the value selected for that particular case will remain the same over multiple plays of the program. This helps provide control and consistency to the random system generation so if I find good samples they can be recorded by their seed string.

Random.Next and Random.NextDouble are going to be the main two that I use, as they help generate random ints or random floating point values (doubles that can be cast as floats if necessary). Random.Next will be very useful in cases where I am generating a specific number of objects, where Random.NextDouble will be used to generate the varied values for parameters that are within specific ranges (such as the length or size of an object). As noted previously Random.NextDouble can only specifically generate values between 0.0 and 1.0, so it will be used as a random multiplication factor to get the results I need.

UnityLearn – Beginner Programming – Creating a Character Stat System – Pt. 03 – Accessing Variables in Our System Part 1

February 12, 2020

Beginner Programming

Creating a Character Stat System

Accessing Variables in Our System Part 1


Beginner Programming: Unity Game Dev Courses

Unity Learn Course – Beginner Programming

Accessing Variables in Our System Part 1

Equipping Weapons

They mostly just created the scriptable object, ItemPickUp_SO, for now so that the base of the EquipWeapon method would work. This method simply adds a designated amount to the character’s base stats.

Equipping Armor

Here they created two separate enums within ItemPickUp_SO to define options for the types of items and options for the types of armor. These enums on the scriptable objects were actually very nice in the editor as they provided drop down lists easily accessible to the designer.

The EquipArmor method in CharacterStats_SO used a switch statement, which goes well with enums. They however performed the same calculations with every single case (adding the different values to the player’s resistances), so I think it would be cleaner to just perform this calculation directly after the switch statement.

Un-Equipping Weapons

Using bool return type methods is useful for equipment systems since you normally want two different events to occur depending on if the player can and successfully equips the item, or if they are unable to equip the item. In their case, they just check if a weapon pickup is the same as the current weapon with the bool field within the bool method UnequipWeapon method. It also checks if there was previously a weapon, and it will destroy the current weapon, set it to null, and return the currentDamage to baseDamage.

Un-Equipping Armor

The UnequipArmor method followed the same idea as the UnequipWeapon method, where it had a return type of bool and returned a value based on whether the item passed in (the item being unequipped in this case) matched the item currently equipped to the player. Since this dealt with armor, they used a switch case again to account for all the various armor types so they could direct the actions at a specific armor slot on the character. This check was similar to what was done in UnequipWeapon again, as it checked if the current slot matched the item being unequipped and then adjusted the current stats (resistance in this case) to the base value and set that item slot to null.

This was repeated for every armor type in the switch case, with the slight difference that they had to change the item slot (specific ItemPickUp field on this particular CharacterStats_SO object). I found it easier to just create a helper method that took in an extra ItemPickUp parameter to determine which ItemPickUp slot was the one being tested and have that method do all the work for that specific slot. This way I only needed that block of code once in the script and only needed a single line for each case in the switch statement.

This ensures everything is uniform (which it currently is according to the tutorial) and keeps the code more organized and cleaner. This may have to be edited if different events are needed for different armor types in the future on unequip, but it’s much better currently.

SUMMARY

  • Enums are very nice on the editor side for scriptable objects since they provide an organized list of options to work with
  • Using bool return type methods can be useful with equip systems
  • Identify repeated code in switch statements to clean/organize code

UnityLearn – Beginner Programming – Creating a Character Stat System – Pt. 02 – Damage, Leveling Up, and Death

February 12, 2020

Beginner Programming: Unity Game Dev Courses

Creating a Character Stat System

Damage, Leveling Up and Death


Beginner Programming: Unity Game Dev Courses

Unity Learn Course – Beginner Programming

Damage, Leveling Up and Death

Encapsulation and Item Pickups

They cover encapsulation again just to explain why they use different access modifiers for different fields and methods within the scriptable objects they are creating to deal with the character’s stats and items.

Stat Increasers

They covered methods that increased the stats of the character. They were pretty basic, where they added values to specific stats and checked if the value would go over the max value to set it directly to max if that was the case.

Stat Reducers

This was very similar to Stat Increasers methods, but with subtraction and checked if the value would go below 0. This made me realize there’s a better way to do this where you check if a value would go below 0 BEFORE actually performing the operation, and then set it to 0 if that is the case. This prevents cases where you make a value negative for any step in the code which could result in weird problems down the road.

Leveling Up and Dying

They took an interesting approach to the level up process. They created a new class within the CharacterStat_SO scriptable object named CharLevelUps. These CharLevelUps objects just contained a bunch of int and float fields for different stats, and would be the amount to increase those base stats upon attaining the next level.

They then created an array of these CharLevelUps objects in the CharacterStat_SO class. You could then see this array in the editor and set a number of them to create (in this case, it would dictate the max level of the player). The designer could then set the individual values for each of these stats for each CharLevelUps object in the array to tell the system how much to increase each stat specifically upon attaining that specific level.

SUMMARY

  • Control your encapsulation when dealing with scriptable objects
  • Make sure to have checks for max and min values when modifying stats
  • Creating new classes that just hold a bunch of fields and then creating an array of those classes can be a very nice modfiable tool for a designer to work with

Unity Learn Tutorials – Artificial Intelligence for Beginners and Intro to Optimization

February 7, 2020

Unity Learn Tutorials

Note: The AI tutorial require Unity Learn Premium to access
Artificial Intelligence for Beginners

Tutorial Series #1 – Link

By: Penny de Byl


Introduction to Optimization with Unity – 2019.3

Tutorial Series #2 – Link

By: Unity Technologies


Notes

These were both tutorial series I saw on Unity Learn that I wanted to note specifically to check out later. The Optimization tutorial is a very small series, so I can look into that rather quickly, but the AI series is a 15+ hour comprehensive class so that will take a large commitment to fully cover.

The AI series however is something I am interested in in general and even covers some topics I am specifically looking into at this time. Some of these topics include: Navigation Meshes, Crowd Simulation, State Machines, and Goal Driven Behavior. This would be very good to follow for my own personal interests as well as possibly being useful for some projects I am looking to work on.

GDC 2020 Talk – Cursed Problems in Game Design

February 6, 2020

Cursed Problems in Game Design

GDC 2020 Talk

GDC 2020: Cursed Problems in Game Design

Video – Link

By: GDC – Alex Jaffe (Riot Games)


Notes

Cursed Problem: an unsolvable design problem, rooted in a conflict between core player promises

Politics: competition through social negotiation, alliances, and manipulation

The main skill here is identifying cursed problems so you know to avoid them or navigate them so you do not waste time on “solving” them.

Examples from Talk: Hard or Cursed?

No Man’s Sky: Exploration game with millions of worlds
Hard: This was evidenced by the game becoming successful after significant time updating the game, but it easy to see this was just a hard problem and not an impossible one.

Diablo: Loot games with efficient trading
Cursed: Many loot experiences are just incompatible with efficient marketplace trading systems because the loot experience relies on the random drops themselves feeling unique or special to the player, but having a market to deal this loot for other loot just makes every type of loot “gold”, or currency, and the specialness of all drops is significantly hampered.
Commodified Reward Problem supports this idea.

Pokemon GO: always-on location-based games
Cursed: These games look to provide an augmented reality layer to real life for rewards, but the counteracting topic is just the general need for personal safety and convenience. The main core of it being cursed is that one is “play anywhere/any time” and the other to make them safe is to “only play when appropriate”.

4 Core Solution Techniques for Cursed Problems

The 4 techniques are: Barriers, Gates, Carrots, S’mores

Barriers

Cut affordances that break promises

This technique focuses on just preventing the player from performing actions that would break the design promise.

Exapmle: Free-For-All Politics (Fortnite, or any large battle royale game)
Approach: Limit player’s agency over one another
Sacrifce: Some of the PvP fantasy of control
The game is so large scale with so many players, high amount of missing information, and high lethality so the political game is not very feasible to develop. It is hard to create an alliance or single out a specific targeted player with all of these variables. This however removes the feeling of “I have outplayed you specifically” or the personal level of domination since the game is so large scale.

Gates

Hide bad states behind challenge

This technique aims to make it harder to find bad ways to play the game so that players will hopefully focus on the good ways intended.

Example: Free-For-All Politics (Playstation All Stars: Battle Royale (4 Player Brawler))
Approach: Limit visibility of players’ success
Sacrifce: Some of the tension of buzzer beaters
They hid the score of each player, and made the scoring system a bit convoluted (2 * kills – deaths) so it was harder to reason out in the middle of the high paced game. This was done to encourage every player playing their best with less fear of being targeted for being in the lead and reduce politics factors. Not being sure of the score however can reduce high tension moments near the end of the game sine no one is really sure who is in the lead and you do not even know who won until they game tells you.

Carrots

Incentivize avoiding the bad states

Provide incentives for players that do not go into the bad game states.

Example: Free-For-All Politics (Catan tournament)
Approach: Add meta-game effects
Sacrifice: Magic circle of an individual game
In a Catan tournament, players play many games and their standings are used to add to their total score for placement. This makes getting first less of a “be all, end all” scenario and incentivizes each player to just do as well as they can. They suggest this ends up reducing overall politics in the game since players are continually incentivized to do their individual best. The con however is that it just makes each individual game feel less special or “magical” to play.

S’mores

Make it fun

This technique leans into the bad states of the game and just make them fun to play as well.

Example: Free-For-All Politics (Diplomacy)
Approach: Give players tools for deep political play (e.g. secrecy)
Sacrifce: Emphasis on moment-to-moment action
The game of Diplomacy goes hard into the politics with secrets and deception along with the gameplay, which can make the political aspects more fun and interesting. This however generally makes the game itself feel like it is taking a backseat (in this case your plays with your units) and leaving players mostly focusing on the relationships they make or break along the way.

Summary

Do not think of these as solutions, but as a small design framework. These techniques were identified to help you approach difficult problems you find in the design process for making a game to help you navigate them more efficiently. It can also just be beneficial to understand some problems are not “solvable” and you will have to make sacrifices to accomplish some goals or mitigate some negative aspects.

Challenges

These were some challenges given as examples of problems so cursed that they really have not been approached very much.

These are the challenges:

  • Balanced player-generated content in multiplayer games
  • PvP games in which all players feel there was a just outcome
  • Mystery and discovery in the age of the internet

The last challenge really resonated with me as something I have investigated, specifically through the concept of procedural content generation.

As an avid Pokemon player I would always go into the new games knowing every new pokemon from information released before hand, whether it was from strategy guides back in the Johto days to the games in the Alola region. I however stumbled upon player made rom games and played them mostly blind and enjoyed them much more. The sense of discovery and figuring things out was so much more interesting and refreshing.

I then got into Pokemon randomizers where you can randomize as much or as little as you want, and that game fresh new life to old games I had played. This gave me the idea for using procedural generation, something akin to the rogue likes of today, but in a more exploratory or experimental way. I think you could look into procedural generation of the rules of the game as opposed to just specific content, and the player could have consistent ways to discover these rules playing the game each time. This way the player’s skill of discovery is really what is emphasized and rewarded as they get better, and they use this core skill to get better at whatever world they are put into.

Exploring NavMesh Capabilities

February 5, 2020

NavMesh

Unity Tutorials

Unity NavMesh Tutorial – Basics

Tutorial #1 – Link

By: Brackeys


Navigation Mesh Basics | Unity AI Pathfinding (Part 1) | Table Flip Games

Tutorial #2 – Link

By: Table Flip Games


Use Unity3D NavMeshAgent.Move to customize your navigation control

Tutorial #3 – Link

By: Jason Weimann


Crowd Behaviours on a Dynamic Navmesh in Unity Part 1

Tutorial #4 – Link

By: Holistic3d


Notes

I am looking to explore Unity’s NavMesh to see what features it has to compare with A* Pathfinding, especially my setup I worked on specifically. I want to see the benefits it readily provides over A* as well as see if I can find any useful features that could be implemented in some way into A*.

Tutorials 2 and 4 both are the beginning of series so they can be useful for exploring deeper into NavMesh. Jason Weimann in tutorial 3 is also generally a good source for exploring features more deeply at a more advanced level.