get good

on getting good
===============

A game is input->output. Repeat. Each cycle of this costs 1 unit time.
A game also has a state. The game state is the memory. All of the variables.
One game state may be observed and agreed upon as the "start"
Another may be observed and agreed upon as the "end"
Measuring the number of input->output cycles that occur between the "start" and "end" is a speedrun.
The goal of a speedrun is to lower this as much as possible.

Some people are adverse to certain glitches because they feel that this system was hacked in some way to bypass "the meat" of the game.
In this case more categories are sometimes created, which involve altering the "end state" to include certain variables to be set to certain states (or prohibiting a certain state from being entered at all).
Categories may be difficult to hammer out sometimes because people disagree on which variables are important and which ones are unimportant.

Anyway, enough about category drama. This is about explaining what speedrunning really is when you want to be good at it.

A speedrun can be modeled as a group of input sequences that give different results in game state.
These game states are known fairly well, and thus also have a predicted time loss as a result of entering that state.
From this, you can measure the approximate time lost in each game state compared to the likely input of a smart player.

standard distribution shows the result of typical input sequence in a run
		      |
		      |
		     /x\
		    /xxx\
		  /xxxxxxx\
_______________/xxxxxxxxxxxxx\________________________________________________________________  time lost
0  0.1               0.5                1                                                10

this is a (mostly) standard distribution model showing the result of human error in a single event within a speedrun.

the far left of the scale is 0 time lost, TAS perfect. it caps at 0 because games don't run at infinite FPS,
so instead of 0.00000000000001 it just suddenly caps at 0 (this is a complex example however)

Depending on the complexity of the input sequence this may become harder to resolve, and even more astronomically unlikely to occur in a realtime run.

even textmashing falls into this system, just with different parameters

		textmash
		  |
		  ||
		  ||
		  | \
		  |  \
		  |   \--
		  |      \----____
		  |-------------------
		  0    1    2    3 frames

in this example the distribution gives you a perfect result most of the time (assuming you mash like me xd)

these distributions can stack upon one another in realtime, making the entire input sequence cluster rather complex.
(an input sequence cluster is the collection of input sequences that are surrounded by 2 bottlenecks in the run, such as the combined set of inputs between two loading zones)


there are variables in speedrunning. the game state.

deku sticks = 0
health = 24

"game state" is the memory of the current game. the memory may hold values that will cause severe branching in the run's path, leading to time differences that are noticable.
the resulting memory from one event may cause a different branch to be taken much later, such as running out of bombs may require a detour 10 minutes later.

more typically you see the game state resulting in measurable smaller time losses:

- Link walks across the field -> 6 seconds
- Link rolls across the field -> 5 seconds

walking appears slower than rolling.

- Link rolls slightly more optimally across the field -> 4.9 seconds

rolling appears to have certain timing rules that affect amount of input->output cycles the game needs to make before reaching the next sequence change / bottleneck.

this input sequence cluster, which one might call "repeated roll timing" may be optimized. You might find the best timing for it and practice it, and apply it universally across many parts of the game.
you may take notice that this is indeed a sequence you have seen before and investigated before. you may make logical conclusions and save yourself the trouble of reinvestigating it.

suddenly, an anamoly appears!

- Upon applying optimized roll timing everywhere in the game, the player finds himself failing a simple jump off of a ledge at a certain place.

upon investigation, if the rolling is applied optimally at this particular point in the game,
the player frequently ends up in a situation where his roll ends slightly before a cliff,
and to make the jump Link has to have built up some speed. As the end of the roll decreases Link's speed, this leads to bad results.

the situation is re-examined, and a new strategy is formed: don't do the last roll if its going to put you right at the edge of the cliff. this way, you won't fall down.

this is how you must logically progress. it is the scientific method, really.


now we know games can be broken down into a web of paths

extremely simple example of a "game" in speedrun format:
Start -> inputsequence -> bottleneck -> inputsequence cluster -> bottleneck -> inputsequence -> End of the game

The entire game may become one giant cluster if enough RNG/complexity/variables are in the run (such as a pokemons different stat growth over the entire run),
although this cluster would become smaller as the goal run time decreases, to a simpler set.

within these paths may be branches, which occur in two forms: manipulatable or unmanipulatable

manipulatable branches are ultimately based off of the input sequences. If the actual resulting game state falls within a certain threshold, the path it takes now changes.

      frame perfect trick (manipulatable branch)
		      |
		      |   distribution is your average reaction time
		     /x\
		    /xxx\
		  /xxxxxxx\
_______________/xxxxxxxxxxxxx\______________
		|    	     |
      A         |      B     |        C
		|            |

path B leads to the best / favorable game state that will progress the game more than the others.
as such, the player as focused their energy around hitting that particular frame. sometimes they miss.

the other paths, A and C, are the result of being one (or more) frames early, or one (or more) frames late.
In some cases there can be a D, E, F... etc depending on timing and complexity of the branches.


start -> input -> output -> input -> output

each output is potential branching based on game state and input.
the programming of the game decides how to handle the input and game state.
the programming are the laws of the game universe. We observe them to be true and after enough analysis we have a certain idea of how they work and interact.

We apply input based on what we know.
With input, comes human error.

Human error creates a huge number of potential runs for somebody to achieve.

The joy of speedrunning is

Discovery - disovering the "laws" and "paths" that people didn't observe previously (ROUTING / GLITCH HUNTING)
Demonstration - showing the world the discovery of the "laws" (TASING / STRAT DEMONSTRATIONS)
The Run - applying your knowledge of these "laws" by executing the input in realtime, and getting back a favorable result (REAL TIME SPEEDRUNNING)

--

Some games have "worse" laws in their universe. Forced branches in which your human input is not capable of affecting RNG loops (Swift Sail in wind waker HD, Dampe heart piece in OoT)
may negatively affect the quality of the experience in attempting to speedrun a game, as it adds unoptimizable variance to a run, which disguises the final time from the quality of play.

       start
         |
         |
      diceroll
         x <--------------------
        / \                     \
       /   \                    /
      |    20 second loss RNG loop
      |
next part of the game
      |
      |
     end

Some games have beautiful examples of laws, such the way bat movement works in Symphony of the Night.
It feels satisfying to play because optimal movement isnt overly repetitious but rather it involves many aspects of the game,
such as the timing delay on a mana prism, the transformation momentum transfer, and the infinite wing smash timing vs screen transitions breaking the input chain.
These things take time to learn and it becomes fun to work on improving your average input.
(each game programming law involved in this decisionmaking multiplies together to increase complexity significantly)

I would reckon that a large part of the enjoyment and popularity of SM64 speedruns is mostly:
The physics and visual display of the game shows exactly what a "close call" is, exactly what "clean movement" is.
This game speaks a lot more easily to a casual viewer because the casual viewer may understand the laws of the game more easily, and see the affect of the player's inputs much more easily.

SM64 can also be seen as having one input series cluster for each loading zone.
This breaks the game into digestible chunks. probably a good thing.
The rise and fall of tension as opposed to it being too lopsided (boring)

SM64 is also a gigantic Nintendo nostalgia game, but I think the above is truly applicable for why Twitch keeps throwing the runs on the front page. The game speaks more easily than others.

--

As you can see, to get good at a speedrun you break the game down into these components and understand the flow and system.

From here you practice your reaction time and muscle memory in preparation for what you have discovered.
Depending on your goal, may you modify or change your input sequences (learn more / modify your ideal input / focus on practicing particular inputs over others).
The objective is to know the consequences of all your most likely inputs while you are running the game, and attempting to discover if there is an improvement to be made to your likely input.

It's really not just reaction time that makes somebody good, but a good understanding of this system. This gives their brain more focus/optimization at playing the game perfectly.

In speedrunning, if you can analyze and break down the input sequences for each game, and practice them, weighing the cost of each input sequence against all the others,
you have routed your game. The more runs you do however the more you tweak and alter your routing slightly. What this is, is altering/swapping input sequences or practicing input sequences.
Human reaction time limits can be trained but a typical speedgame is so complex that it goes far beyond just the human reaction time -- it goes into your insight as to WHAT THE GAME IS at its true core.

The reason I love games like Ocarina of Time are not necessarily the typical physics of movement but rather the unlikely miracles that come together to cut off huge chunks of time.
By some outstanding luck, the universe we are discovering "Ocarina of Time" happens to have an RBA Chain that gives you most things you need in order.
It has the castle collapse interior adjacent to the deku tree basement on the entrance list. It has the Door of Time uncentered just enough to give it a 0.791015625° angle of clipping.
Zero point eight degrees wide or else it would be impossible. If you clip for the void warp you fall the exact number of frames to trigger the wrong coordinates to be used, which happen to be advantageous.

We know the creators didn't intend these things.

These are beautiful anamolies in a foreign universe.

sorry if this made no sense. it is 5 in the morning.
-Cosmo